OtlpExporter: HttpClientFactory option

src/OpenTelemetry.Exporter.Jaeger/README.md

@@ -96,11 +96,15 @@ implementation if you want to customize the generated `HttpClient`:
 
 ```csharp
 services.AddOpenTelemetryTracing((builder) => builder
-    .AddJaegerExporter(o => o.HttpClientFactory = () =>
+    .AddJaegerExporter(o =>
     {
-        HttpClient client = new HttpClient();
-        client.DefaultRequestHeaders.Add("X-MyCustomHeader", "value");
-        return client;
+        o.Protocol = JaegerExportProtocol.HttpBinaryThrift;
+        o.HttpClientFactory = () =>
+        {
+            HttpClient client = new HttpClient();
+            client.DefaultRequestHeaders.Add("X-MyCustomHeader", "value");
+            return client;
+        };
     }));
 ```
 

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/.publicApi/net461/PublicAPI.Unshipped.txt

@@ -13,6 +13,8 @@ OpenTelemetry.Exporter.OtlpExporterOptions.MetricReaderType.get -> OpenTelemetry
 OpenTelemetry.Exporter.OtlpExporterOptions.MetricReaderType.set -> void
 OpenTelemetry.Exporter.OtlpExporterOptions.PeriodicExportingMetricReaderOptions.get -> OpenTelemetry.Metrics.PeriodicExportingMetricReaderOptions
 OpenTelemetry.Exporter.OtlpExporterOptions.PeriodicExportingMetricReaderOptions.set -> void
+OpenTelemetry.Exporter.OtlpExporterOptions.HttpClientFactory.get -> System.Func<System.Net.Http.HttpClient>
+OpenTelemetry.Exporter.OtlpExporterOptions.HttpClientFactory.set -> void
 OpenTelemetry.Exporter.OtlpExporterOptions.OtlpExporterOptions() -> void
 OpenTelemetry.Exporter.OtlpExporterOptions.Protocol.get -> OpenTelemetry.Exporter.OtlpExportProtocol
 OpenTelemetry.Exporter.OtlpExporterOptions.Protocol.set -> void

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/.publicApi/net5.0/PublicAPI.Unshipped.txt

@@ -4,6 +4,8 @@ OpenTelemetry.Exporter.OtlpExporterOptions.MetricReaderType.get -> OpenTelemetry
 OpenTelemetry.Exporter.OtlpExporterOptions.MetricReaderType.set -> void
 OpenTelemetry.Exporter.OtlpExporterOptions.PeriodicExportingMetricReaderOptions.get -> OpenTelemetry.Metrics.PeriodicExportingMetricReaderOptions
 OpenTelemetry.Exporter.OtlpExporterOptions.PeriodicExportingMetricReaderOptions.set -> void
+OpenTelemetry.Exporter.OtlpExporterOptions.HttpClientFactory.get -> System.Func<System.Net.Http.HttpClient>
+OpenTelemetry.Exporter.OtlpExporterOptions.HttpClientFactory.set -> void
 OpenTelemetry.Exporter.OtlpExporterOptions.Protocol.get -> OpenTelemetry.Exporter.OtlpExportProtocol
 OpenTelemetry.Exporter.OtlpExporterOptions.Protocol.set -> void
 OpenTelemetry.Exporter.OtlpExportProtocol

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/.publicApi/netstandard2.0/PublicAPI.Unshipped.txt

@@ -4,6 +4,8 @@ OpenTelemetry.Exporter.OtlpExporterOptions.MetricReaderType.get -> OpenTelemetry
 OpenTelemetry.Exporter.OtlpExporterOptions.MetricReaderType.set -> void
 OpenTelemetry.Exporter.OtlpExporterOptions.PeriodicExportingMetricReaderOptions.get -> OpenTelemetry.Metrics.PeriodicExportingMetricReaderOptions
 OpenTelemetry.Exporter.OtlpExporterOptions.PeriodicExportingMetricReaderOptions.set -> void
+OpenTelemetry.Exporter.OtlpExporterOptions.HttpClientFactory.get -> System.Func<System.Net.Http.HttpClient>
+OpenTelemetry.Exporter.OtlpExporterOptions.HttpClientFactory.set -> void
 OpenTelemetry.Exporter.OtlpExporterOptions.Protocol.get -> OpenTelemetry.Exporter.OtlpExportProtocol
 OpenTelemetry.Exporter.OtlpExporterOptions.Protocol.set -> void
 OpenTelemetry.Exporter.OtlpExportProtocol

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/.publicApi/netstandard2.1/PublicAPI.Unshipped.txt

@@ -4,6 +4,8 @@ OpenTelemetry.Exporter.OtlpExporterOptions.MetricReaderType.get -> OpenTelemetry
 OpenTelemetry.Exporter.OtlpExporterOptions.MetricReaderType.set -> void
 OpenTelemetry.Exporter.OtlpExporterOptions.PeriodicExportingMetricReaderOptions.get -> OpenTelemetry.Metrics.PeriodicExportingMetricReaderOptions
 OpenTelemetry.Exporter.OtlpExporterOptions.PeriodicExportingMetricReaderOptions.set -> void
+OpenTelemetry.Exporter.OtlpExporterOptions.HttpClientFactory.get -> System.Func<System.Net.Http.HttpClient>
+OpenTelemetry.Exporter.OtlpExporterOptions.HttpClientFactory.set -> void
 OpenTelemetry.Exporter.OtlpExporterOptions.Protocol.get -> OpenTelemetry.Exporter.OtlpExportProtocol
 OpenTelemetry.Exporter.OtlpExporterOptions.Protocol.set -> void
 OpenTelemetry.Exporter.OtlpExportProtocol

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/CHANGELOG.md

@@ -6,6 +6,10 @@
   the `OtlpMetricExporter` to export either manually or periodically.
   ([#2674](https://github.com/open-telemetry/opentelemetry-dotnet/pull/2674))
 
+* Support `HttpProtobuf` protocol with metrics & added `HttpClientFactory`
+  option
+  ([#2696](https://github.com/open-telemetry/opentelemetry-dotnet/pull/2696))
+
 ## 1.2.0-beta2
 
 Released 2021-Nov-19

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ExportClient/BaseOtlpHttpExportClient.cs

@@ -14,7 +14,6 @@
 // limitations under the License.
 // </copyright>
 
-using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Threading;
@@ -26,14 +25,15 @@ namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClie
     /// <typeparam name="TRequest">Type of export request.</typeparam>
     internal abstract class BaseOtlpHttpExportClient<TRequest> : IExportClient<TRequest>
     {
-        protected BaseOtlpHttpExportClient(OtlpExporterOptions options, HttpClient httpClient = null)
+        protected BaseOtlpHttpExportClient(OtlpExporterOptions options, HttpClient httpClient)
         {
             Guard.Null(options, nameof(options));
+            Guard.Null(httpClient, nameof(httpClient));
             Guard.InvalidTimeout(options.TimeoutMilliseconds, $"{nameof(options)}.{nameof(options.TimeoutMilliseconds)}");
 
             this.Options = options;
             this.Headers = options.GetHeaders<Dictionary<string, string>>((d, k, v) => d.Add(k, v));
-            this.HttpClient = httpClient ?? new HttpClient { Timeout = TimeSpan.FromMilliseconds(this.Options.TimeoutMilliseconds) };
+            this.HttpClient = httpClient;
         }
 
         internal OtlpExporterOptions Options { get; }

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ExportClient/OtlpHttpMetricsExportClient.cs

@@ -0,0 +1,96 @@
+// <copyright file="OtlpHttpMetricsExportClient.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Runtime.CompilerServices;
+#if NET5_0_OR_GREATER
+using System.Threading;
+#endif
+using System.Threading.Tasks;
+using Google.Protobuf;
+using OtlpCollector = Opentelemetry.Proto.Collector.Metrics.V1;
+
+namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClient
+{
+    /// <summary>Class for sending OTLP metrics export request over HTTP.</summary>
+    internal sealed class OtlpHttpMetricsExportClient : BaseOtlpHttpExportClient<OtlpCollector.ExportMetricsServiceRequest>
+    {
+        internal const string MediaContentType = "application/x-protobuf";
+        private readonly Uri exportMetricsUri;
+
+        public OtlpHttpMetricsExportClient(OtlpExporterOptions options, HttpClient httpClient)
+            : base(options, httpClient)
+        {
+            this.exportMetricsUri = this.Options.Endpoint;
+        }
+
+        protected override HttpRequestMessage CreateHttpRequest(OtlpCollector.ExportMetricsServiceRequest exportRequest)
+        {
+            var request = new HttpRequestMessage(HttpMethod.Post, this.exportMetricsUri);
+            foreach (var header in this.Headers)
+            {
+                request.Headers.Add(header.Key, header.Value);
+            }
+
+            request.Content = new ExportRequestContent(exportRequest);
+
+            return request;
+        }
+
+        internal sealed class ExportRequestContent : HttpContent
+        {
+            private static readonly MediaTypeHeaderValue ProtobufMediaTypeHeader = new MediaTypeHeaderValue(MediaContentType);
+
+            private readonly OtlpCollector.ExportMetricsServiceRequest exportRequest;
+
+            public ExportRequestContent(OtlpCollector.ExportMetricsServiceRequest exportRequest)
+            {
+                this.exportRequest = exportRequest;
+                this.Headers.ContentType = ProtobufMediaTypeHeader;
+            }
+
+#if NET5_0_OR_GREATER
+            protected override void SerializeToStream(Stream stream, TransportContext context, CancellationToken cancellationToken)
+            {
+                this.SerializeToStreamInternal(stream);
+            }
+#endif
+
+            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
+            {
+                this.SerializeToStreamInternal(stream);
+                return Task.CompletedTask;
+            }
+
+            protected override bool TryComputeLength(out long length)
+            {
+                // We can't know the length of the content being pushed to the output stream.
+                length = -1;
+                return false;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            private void SerializeToStreamInternal(Stream stream)
+            {
+                this.exportRequest.WriteTo(stream);
+            }
+        }
+    }
+}

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ExportClient/OtlpHttpTraceExportClient.cs

@@ -35,7 +35,7 @@ internal sealed class OtlpHttpTraceExportClient : BaseOtlpHttpExportClient<OtlpC
         internal const string MediaContentType = "application/x-protobuf";
         private readonly Uri exportTracesUri;
 
-        public OtlpHttpTraceExportClient(OtlpExporterOptions options, HttpClient httpClient = null)
+        public OtlpHttpTraceExportClient(OtlpExporterOptions options, HttpClient httpClient)
             : base(options, httpClient)
         {
             this.exportTracesUri = this.Options.Endpoint;

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpExporterOptions.cs

@@ -16,6 +16,7 @@
 
 using System;
 using System.Diagnostics;
+using System.Net.Http;
 using OpenTelemetry.Internal;
 using OpenTelemetry.Metrics;
 using OpenTelemetry.Trace;
@@ -41,6 +42,8 @@ public class OtlpExporterOptions
         internal const string TracesExportPath = "v1/traces";
         internal const string MetricsExportPath = "v1/metrics";
 
+        internal readonly Func<HttpClient> DefaultHttpClientFactory;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="OtlpExporterOptions"/> class.
         /// </summary>
@@ -73,6 +76,14 @@ public OtlpExporterOptions()
                     throw new FormatException($"{ProtocolEnvVarName} environment variable has an invalid value: '${protocolEnvVar}'");
                 }
             }
+
+            this.HttpClientFactory = this.DefaultHttpClientFactory = () =>
+            {
+                return new HttpClient()
+                {
+                    Timeout = TimeSpan.FromMilliseconds(this.TimeoutMilliseconds),
+                };
+            };
         }
 
         /// <summary>
@@ -123,5 +134,38 @@ public OtlpExporterOptions()
         /// and Sum metrics.
         /// </summary>
         public AggregationTemporality AggregationTemporality { get; set; } = AggregationTemporality.Cumulative;
+
+        /// <summary>
+        /// Gets or sets the factory function called to create the <see
+        /// cref="HttpClient"/> instance that will be used at runtime to
+        /// transmit spans over HTTP. The returned instance will be reused for
+        /// all export invocations.
+        /// </summary>
+        /// <remarks>
+        /// Notes:
+        /// <list type="bullet">
+        /// <item>This is only invoked for the <see
+        /// cref="OtlpExportProtocol.HttpProtobuf"/> protocol.</item>
+        /// <item>The default behavior when using the <see
+        /// cref="OtlpTraceExporterHelperExtensions.AddOtlpExporter(TracerProviderBuilder,
+        /// Action{OtlpExporterOptions})"/> extension is if an <a
+        /// href="https://docs.microsoft.com/dotnet/api/system.net.http.ihttpclientfactory">IHttpClientFactory</a>
+        /// instance can be resolved through the application <see
+        /// cref="IServiceProvider"/> then an <see cref="HttpClient"/> will be
+        /// created through the factory with the name "OtlpTraceExporter"
+        /// otherwise an <see cref="HttpClient"/> will be instantiated
+        /// directly.</item>
+        /// <item>The default behavior when using the <see
+        /// cref="OtlpMetricExporterExtensions.AddOtlpExporter(MeterProviderBuilder,
+        /// Action{OtlpExporterOptions})"/> extension is if an <a
+        /// href="https://docs.microsoft.com/dotnet/api/system.net.http.ihttpclientfactory">IHttpClientFactory</a>
+        /// instance can be resolved through the application <see
+        /// cref="IServiceProvider"/> then an <see cref="HttpClient"/> will be
+        /// created through the factory with the name "OtlpMetricExporter"
+        /// otherwise an <see cref="HttpClient"/> will be instantiated
+        /// directly.</item>
+        /// </list>
+        /// </remarks>
+        public Func<HttpClient> HttpClientFactory { get; set; }
     }
 }

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpExporterOptionsExtensions.cs

@@ -21,7 +21,8 @@
 #if NETSTANDARD2_1 || NET5_0_OR_GREATER
 using Grpc.Net.Client;
 #endif
-using OtlpCollector = Opentelemetry.Proto.Collector.Trace.V1;
+using MetricsOtlpCollector = Opentelemetry.Proto.Collector.Metrics.V1;
+using TraceOtlpCollector = Opentelemetry.Proto.Collector.Trace.V1;
 
 namespace OpenTelemetry.Exporter
 {
@@ -88,11 +89,23 @@ public static THeaders GetHeaders<THeaders>(this OtlpExporterOptions options, Ac
             return headers;
         }
 
-        public static IExportClient<OtlpCollector.ExportTraceServiceRequest> GetTraceExportClient(this OtlpExporterOptions options) =>
+        public static IExportClient<TraceOtlpCollector.ExportTraceServiceRequest> GetTraceExportClient(this OtlpExporterOptions options) =>
             options.Protocol switch
             {
                 OtlpExportProtocol.Grpc => new OtlpGrpcTraceExportClient(options),
-                OtlpExportProtocol.HttpProtobuf => new OtlpHttpTraceExportClient(options),
+                OtlpExportProtocol.HttpProtobuf => new OtlpHttpTraceExportClient(
+                    options,
+                    options.HttpClientFactory?.Invoke() ?? throw new InvalidOperationException("OtlpExporterOptions was missing HttpClientFactory or it returned null.")),
+                _ => throw new NotSupportedException($"Protocol {options.Protocol} is not supported."),
+            };
+
+        public static IExportClient<MetricsOtlpCollector.ExportMetricsServiceRequest> GetMetricsExportClient(this OtlpExporterOptions options) =>
+            options.Protocol switch
+            {
+                OtlpExportProtocol.Grpc => new OtlpGrpcMetricsExportClient(options),
+                OtlpExportProtocol.HttpProtobuf => new OtlpHttpMetricsExportClient(
+                    options,
+                    options.HttpClientFactory?.Invoke() ?? throw new InvalidOperationException("OtlpExporterOptions was missing HttpClientFactory or it returned null.")),
                 _ => throw new NotSupportedException($"Protocol {options.Protocol} is not supported."),
             };
 

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporter.cs

@@ -55,8 +55,7 @@ internal OtlpMetricExporter(OtlpExporterOptions options, IExportClient<OtlpColle
             }
             else
             {
-                // TODO: this instantiation should be aligned with the protocol option (grpc or http/protobuf) when OtlpHttpMetricsExportClient will be implemented.
-                this.exportClient = new OtlpGrpcMetricsExportClient(options);
+                this.exportClient = options.GetMetricsExportClient();
             }
         }
 

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpMetricExporterExtensions.cs

@@ -17,6 +17,7 @@
 using System;
 using OpenTelemetry.Exporter;
 using OpenTelemetry.Internal;
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry.Metrics
 {
@@ -39,19 +40,25 @@ public static MeterProviderBuilder AddOtlpExporter(this MeterProviderBuilder bui
             {
                 return deferredMeterProviderBuilder.Configure((sp, builder) =>
                 {
-                    AddOtlpExporter(builder, sp.GetOptions<OtlpExporterOptions>(), configure);
+                    AddOtlpExporter(builder, sp.GetOptions<OtlpExporterOptions>(), configure, sp);
                 });
             }
 
-            return AddOtlpExporter(builder, new OtlpExporterOptions(), configure);
+            return AddOtlpExporter(builder, new OtlpExporterOptions(), configure, serviceProvider: null);
         }
 
-        private static MeterProviderBuilder AddOtlpExporter(MeterProviderBuilder builder, OtlpExporterOptions options, Action<OtlpExporterOptions> configure = null)
+        private static MeterProviderBuilder AddOtlpExporter(
+            MeterProviderBuilder builder,
+            OtlpExporterOptions options,
+            Action<OtlpExporterOptions> configure,
+            IServiceProvider serviceProvider)
         {
             var initialEndpoint = options.Endpoint;
 
             configure?.Invoke(options);
 
+            OtlpTraceExporterHelperExtensions.BuildHttpClientFactory(serviceProvider, options, "OtlpMetricExporter");
+
             options.AppendExportPath(initialEndpoint, OtlpExporterOptions.MetricsExportPath);
 
             var metricExporter = new OtlpMetricExporter(options);