[otlp] UseOtlpExporter cross-cutting extension

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Builder/OpenTelemetryBuilderOtlpExporterExtensions.cs

@@ -106,7 +106,7 @@ internal static IOpenTelemetryBuilder UseOtlpExporter(
         string? name = null,
         IConfiguration? configuration = null,
         Action<OtlpExporterBuilder>? configure = null,
-        bool addToEndOfPipeline = true)
+        ProcessorPipelineWeight processorPipelineWeight = ProcessorPipelineWeight.PipelineExporter)
     {
         Guard.ThrowIfNull(builder);
 
@@ -119,12 +119,12 @@ internal static IOpenTelemetryBuilder UseOtlpExporter(
 
         configure?.Invoke(otlpBuilder);
 
-        UseOtlpExporterInternal(builder, name, addToEndOfPipeline);
+        UseOtlpExporterInternal(builder, name, processorPipelineWeight);
 
         return builder;
     }
 
-    private static void UseOtlpExporterInternal(IOpenTelemetryBuilder builder, string? name, bool addToEndOfPipeline)
+    private static void UseOtlpExporterInternal(IOpenTelemetryBuilder builder, string? name, ProcessorPipelineWeight processorPipelineWeight)
     {
         builder
             .WithLogging()
@@ -159,12 +159,12 @@ private static void UseOtlpExporterInternal(IOpenTelemetryBuilder builder, strin
 
                 var processor = OtlpLogExporterHelperExtensions.BuildOtlpLogExporter(
                     sp,
-                    builderOptions.LoggingOptions.ApplyDefaults(builderOptions.DefaultOptions),
+                    builderOptions.LoggingOptionsInstance.ApplyDefaults(builderOptions.DefaultOptionsInstance),
                     builderOptions.LogRecordExportProcessorOptions ?? throw new NotSupportedException(),
                     builderOptions.SdkLimitOptions,
                     builderOptions.ExperimentalOptions);
 
-                processor.Weight = addToEndOfPipeline ? int.MaxValue : 0;
+                processor.PipelineWeight = processorPipelineWeight;
 
                 logging.AddProcessor(processor);
             });
@@ -181,7 +181,7 @@ private static void UseOtlpExporterInternal(IOpenTelemetryBuilder builder, strin
 
                 metrics.AddReader(
                     OtlpMetricExporterExtensions.BuildOtlpExporterMetricReader(
-                        builderOptions.MetricsOptions.ApplyDefaults(builderOptions.DefaultOptions),
+                        builderOptions.MetricsOptionsInstance.ApplyDefaults(builderOptions.DefaultOptionsInstance),
                         builderOptions.MetricReaderOptions ?? throw new NotSupportedException(),
                         sp));
             });
@@ -199,13 +199,13 @@ private static void UseOtlpExporterInternal(IOpenTelemetryBuilder builder, strin
                 var processorOptions = builderOptions.ActivityExportProcessorOptions ?? throw new NotSupportedException();
 
                 var processor = OtlpTraceExporterHelperExtensions.BuildOtlpExporterProcessor(
-                    builderOptions.TracingOptions.ApplyDefaults(builderOptions.DefaultOptions),
+                    builderOptions.TracingOptionsInstance.ApplyDefaults(builderOptions.DefaultOptionsInstance),
                     builderOptions.SdkLimitOptions,
                     processorOptions.ExportProcessorType,
                     processorOptions.BatchExportProcessorOptions,
                     sp);
 
-                processor.Weight = addToEndOfPipeline ? int.MaxValue : 0;
+                processor.PipelineWeight = processorPipelineWeight;
 
                 tracing.AddProcessor(processor);
             });

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Builder/OtlpExporterBuilder.cs

@@ -46,7 +46,7 @@ public OtlpExporterBuilder SetSignalsToConfigure(OtlpExporterSignals signalsToCo
     }
 
     public OtlpExporterBuilder ConfigureDefaultExporterOptions(
-        Action<OtlpExporterOptionsBase> configure)
+        Action<IOtlpExporterOptions> configure)
     {
         Guard.ThrowIfNull(configure);
 
@@ -57,7 +57,7 @@ public OtlpExporterBuilder ConfigureDefaultExporterOptions(
     }
 
     public OtlpExporterBuilder ConfigureLoggingExporterOptions(
-        Action<OtlpExporterOptionsBase> configure)
+        Action<IOtlpExporterOptions> configure)
     {
         Guard.ThrowIfNull(configure);
 
@@ -77,7 +77,7 @@ public OtlpExporterBuilder ConfigureLoggingProcessorOptions(
     }
 
     public OtlpExporterBuilder ConfigureMetricsExporterOptions(
-        Action<OtlpExporterOptionsBase> configure)
+        Action<IOtlpExporterOptions> configure)
     {
         Guard.ThrowIfNull(configure);
 
@@ -97,7 +97,7 @@ public OtlpExporterBuilder ConfigureMetricsReaderOptions(
     }
 
     public OtlpExporterBuilder ConfigureTracingExporterOptions(
-        Action<OtlpExporterOptionsBase> configure)
+        Action<IOtlpExporterOptions> configure)
     {
         Guard.ThrowIfNull(configure);
 

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Builder/OtlpExporterBuilderOptions.cs

@@ -20,6 +20,11 @@ internal sealed class OtlpExporterBuilderOptions
     internal readonly MetricReaderOptions? MetricReaderOptions;
     internal readonly ActivityExportProcessorOptions? ActivityExportProcessorOptions;
 
+    internal readonly OtlpExporterOptions DefaultOptionsInstance;
+    internal readonly OtlpExporterOptions LoggingOptionsInstance;
+    internal readonly OtlpExporterOptions MetricsOptionsInstance;
+    internal readonly OtlpExporterOptions TracingOptionsInstance;
+
     public OtlpExporterBuilderOptions(
         IConfiguration configuration,
         SdkLimitOptions sdkLimitOptions,
@@ -38,22 +43,24 @@ public OtlpExporterBuilderOptions(
         this.MetricReaderOptions = metricReaderOptions;
         this.ActivityExportProcessorOptions = activityExportProcessorOptions;
 
-        this.DefaultOptions = new OtlpExporterOptionsBase(configuration!, OtlpExporterSignals.None);
+        var defaultBatchOptions = this.ActivityExportProcessorOptions!.BatchExportProcessorOptions;
+
+        this.DefaultOptionsInstance = new OtlpExporterOptions(configuration!, OtlpExporterSignals.None, defaultBatchOptions);
 
-        this.LoggingOptions = new OtlpExporterOptionsBase(configuration!, OtlpExporterSignals.Logs);
+        this.LoggingOptionsInstance = new OtlpExporterOptions(configuration!, OtlpExporterSignals.Logs, defaultBatchOptions);
 
-        this.MetricsOptions = new OtlpExporterOptionsBase(configuration!, OtlpExporterSignals.Metrics);
+        this.MetricsOptionsInstance = new OtlpExporterOptions(configuration!, OtlpExporterSignals.Metrics, defaultBatchOptions);
 
-        this.TracingOptions = new OtlpExporterOptionsBase(configuration!, OtlpExporterSignals.Traces);
+        this.TracingOptionsInstance = new OtlpExporterOptions(configuration!, OtlpExporterSignals.Traces, defaultBatchOptions);
     }
 
     public OtlpExporterSignals Signals { get; set; } = OtlpExporterSignals.All;
 
-    public OtlpExporterOptionsBase DefaultOptions { get; }
+    public IOtlpExporterOptions DefaultOptions => this.DefaultOptionsInstance;
 
-    public OtlpExporterOptionsBase LoggingOptions { get; }
+    public IOtlpExporterOptions LoggingOptions => this.LoggingOptionsInstance;
 
-    public OtlpExporterOptionsBase MetricsOptions { get; }
+    public IOtlpExporterOptions MetricsOptions => this.MetricsOptionsInstance;
 
-    public OtlpExporterOptionsBase TracingOptions { get; }
+    public IOtlpExporterOptions TracingOptions => this.TracingOptionsInstance;
 }

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/IOtlpExporterOptions.cs

@@ -0,0 +1,95 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#nullable enable
+
+#if NETFRAMEWORK
+using System.Net.Http;
+#endif
+
+namespace OpenTelemetry.Exporter;
+
+/// <summary>
+/// Describes the OpenTelemetry Protocol (OTLP) exporter options shared by all
+/// signals.
+/// </summary>
+internal interface IOtlpExporterOptions
+{
+    /// <summary>
+    /// Gets or sets the the OTLP transport protocol.
+    /// </summary>
+    OtlpExportProtocol Protocol { get; set; }
+
+    /// <summary>
+    /// Gets or sets the target to which the exporter is going to send
+    /// telemetry.
+    /// </summary>
+    /// <remarks>
+    /// Notes:
+    /// <list type="bullet">
+    /// <item><see cref="Endpoint"/> must be a valid <see cref="Uri"/> with
+    /// scheme (http or https) and host, and may contain a port and path.</item>
+    /// <item>The default value is based on the <see cref="Protocol"/> property:
+    /// <list type="bullet">
+    /// <item><c>http://localhost:4317</c> for <see
+    /// cref="OtlpExportProtocol.Grpc"/>.</item>
+    /// <item><c>http://localhost:4318</c> for <see
+    /// cref="OtlpExportProtocol.HttpProtobuf"/></item>.
+    /// </list>
+    /// </item>
+    /// </list>
+    /// </remarks>
+    Uri Endpoint { get; set; }
+
+    /// <summary>
+    /// Gets or sets optional headers for the connection.
+    /// </summary>
+    /// <remarks>
+    /// Note: Refer to the  <see
+    /// href="https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#specifying-headers-via-environment-variables">
+    /// OpenTelemetry Specification</see> for details on the format of <see
+    /// cref="Headers"/>.
+    /// </remarks>
+    string? Headers { get; set; }
+
+    /// <summary>
+    /// Gets or sets the max waiting time (in milliseconds) for the backend to
+    /// process each batch. Default value: <c>10000</c>.
+    /// </summary>
+    int TimeoutMilliseconds { get; set; }
+
+    /// <summary>
+    /// Gets or sets the factory function called to create the <see
+    /// cref="HttpClient"/> instance that will be used at runtime to
+    /// transmit telemetry 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 tracing registration extensions 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 metrics registration extensions 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>
+    /// <item>
+    /// The default behavior when using logging registration extensions is an
+    /// <see cref="HttpClient"/> will be instantiated directly. <a
+    /// href="https://docs.microsoft.com/dotnet/api/system.net.http.ihttpclientfactory">IHttpClientFactory</a>
+    /// is not currently supported for logging.
+    /// </item>
+    /// </list>
+    /// </remarks>
+    Func<HttpClient> HttpClientFactory { get; set; }
+}

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

@@ -15,7 +15,7 @@ internal abstract class BaseOtlpGrpcExportClient<TRequest> : IExportClient<TRequ
 {
     protected static readonly ExportClientGrpcResponse SuccessExportResponse = new ExportClientGrpcResponse(success: true, deadlineUtc: null, exception: null);
 
-    protected BaseOtlpGrpcExportClient(OtlpExporterOptionsBase options)
+    protected BaseOtlpGrpcExportClient(OtlpExporterOptions options)
     {
         Guard.ThrowIfNull(options);
         Guard.ThrowIfInvalidTimeout(options.TimeoutMilliseconds);

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

@@ -14,7 +14,7 @@ internal abstract class BaseOtlpHttpExportClient<TRequest> : IExportClient<TRequ
 {
     private static readonly ExportClientHttpResponse SuccessExportResponse = new ExportClientHttpResponse(success: true, deadlineUtc: null, response: null, exception: null);
 
-    protected BaseOtlpHttpExportClient(OtlpExporterOptionsBase options, HttpClient httpClient, string signalPath)
+    protected BaseOtlpHttpExportClient(OtlpExporterOptions options, HttpClient httpClient, string signalPath)
     {
         Guard.ThrowIfNull(options);
         Guard.ThrowIfNull(httpClient);

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

@@ -5,7 +5,7 @@ namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation.ExportClie
 
 internal static class ExporterClientValidation
 {
-    internal static void EnsureUnencryptedSupportIsEnabled(OtlpExporterOptionsBase options)
+    internal static void EnsureUnencryptedSupportIsEnabled(OtlpExporterOptions options)
     {
         var version = Environment.Version;
 

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

@@ -11,7 +11,7 @@ internal sealed class OtlpGrpcLogExportClient : BaseOtlpGrpcExportClient<OtlpCol
 {
     private readonly OtlpCollector.LogsService.LogsServiceClient logsClient;
 
-    public OtlpGrpcLogExportClient(OtlpExporterOptionsBase options, OtlpCollector.LogsService.LogsServiceClient logsServiceClient = null)
+    public OtlpGrpcLogExportClient(OtlpExporterOptions options, OtlpCollector.LogsService.LogsServiceClient logsServiceClient = null)
         : base(options)
     {
         if (logsServiceClient != null)

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

@@ -11,7 +11,7 @@ internal sealed class OtlpGrpcMetricsExportClient : BaseOtlpGrpcExportClient<Otl
 {
     private readonly OtlpCollector.MetricsService.MetricsServiceClient metricsClient;
 
-    public OtlpGrpcMetricsExportClient(OtlpExporterOptionsBase options, OtlpCollector.MetricsService.MetricsServiceClient metricsServiceClient = null)
+    public OtlpGrpcMetricsExportClient(OtlpExporterOptions options, OtlpCollector.MetricsService.MetricsServiceClient metricsServiceClient = null)
         : base(options)
     {
         if (metricsServiceClient != null)

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

@@ -11,7 +11,7 @@ internal sealed class OtlpGrpcTraceExportClient : BaseOtlpGrpcExportClient<OtlpC
 {
     private readonly OtlpCollector.TraceService.TraceServiceClient traceClient;
 
-    public OtlpGrpcTraceExportClient(OtlpExporterOptionsBase options, OtlpCollector.TraceService.TraceServiceClient traceServiceClient = null)
+    public OtlpGrpcTraceExportClient(OtlpExporterOptions options, OtlpCollector.TraceService.TraceServiceClient traceServiceClient = null)
         : base(options)
     {
         if (traceServiceClient != null)

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

@@ -18,7 +18,7 @@ internal sealed class OtlpHttpLogExportClient : BaseOtlpHttpExportClient<OtlpCol
     internal const string MediaContentType = "application/x-protobuf";
     private const string LogsExportPath = "v1/logs";
 
-    public OtlpHttpLogExportClient(OtlpExporterOptionsBase options, HttpClient httpClient)
+    public OtlpHttpLogExportClient(OtlpExporterOptions options, HttpClient httpClient)
         : base(options, httpClient, LogsExportPath)
     {
     }

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

@@ -18,7 +18,7 @@ internal sealed class OtlpHttpMetricsExportClient : BaseOtlpHttpExportClient<Otl
     internal const string MediaContentType = "application/x-protobuf";
     private const string MetricsExportPath = "v1/metrics";
 
-    public OtlpHttpMetricsExportClient(OtlpExporterOptionsBase options, HttpClient httpClient)
+    public OtlpHttpMetricsExportClient(OtlpExporterOptions options, HttpClient httpClient)
         : base(options, httpClient, MetricsExportPath)
     {
     }

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

@@ -18,7 +18,7 @@ internal sealed class OtlpHttpTraceExportClient : BaseOtlpHttpExportClient<OtlpC
     internal const string MediaContentType = "application/x-protobuf";
     private const string TracesExportPath = "v1/traces";
 
-    public OtlpHttpTraceExportClient(OtlpExporterOptionsBase options, HttpClient httpClient)
+    public OtlpHttpTraceExportClient(OtlpExporterOptions options, HttpClient httpClient)
         : base(options, httpClient, TracesExportPath)
     {
     }