OtlpExporter cross-cutting registration extension rough draft.

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OpenTelemetryBuilderOtlpExporterExtensions.cs

@@ -0,0 +1,111 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#nullable enable
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using OpenTelemetry.Exporter;
+using OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation;
+using OpenTelemetry.Internal;
+using OpenTelemetry.Logs;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry;
+
+public static class OpenTelemetryBuilderOtlpExporterExtensions
+{
+    public static IOpenTelemetryBuilder AddOtlpExporter(
+        this IOpenTelemetryBuilder builder)
+        => AddOtlpExporter(builder, name: null, configure: null);
+
+    public static IOpenTelemetryBuilder AddOtlpExporter(
+        this IOpenTelemetryBuilder builder,
+        Action<OtlpExporterBuilderOptions>? configure)
+        => AddOtlpExporter(builder, name: null, configure);
+
+    public static IOpenTelemetryBuilder AddOtlpExporter(
+        this IOpenTelemetryBuilder builder,
+        string? name,
+        Action<OtlpExporterBuilderOptions>? configure)
+    {
+        Guard.ThrowIfNull(builder);
+
+        builder.Services.RegisterOptionsFactory(configuration => new SdkLimitOptions(configuration));
+        builder.Services.RegisterOptionsFactory(configuration => new ExperimentalOptions(configuration));
+
+        builder.Services.RegisterOptionsFactory(
+            (sp, config, name) =>
+            new OtlpExporterBuilderOptions(
+                config,
+                sp.GetRequiredService<IOptionsMonitor<ActivityExportProcessorOptions>>().Get(name)));
+
+        name ??= Options.DefaultName;
+
+        if (configure != null)
+        {
+            builder.Services.Configure(name, configure);
+        }
+
+        builder.Services.ConfigureOpenTelemetryLoggerProvider(
+            (sp, logging) =>
+            {
+                var builderOptions = GetOptions(sp, name);
+
+                if (!builderOptions.AddToLoggerProvider)
+                {
+                    return;
+                }
+
+                logging.AddProcessor(
+                    OtlpLogExporterHelperExtensions.BuildOtlpLogExporter(
+                        sp,
+                        OtlpExporterOptions.Merge(builderOptions.DefaultOptions, builderOptions.LoggingOptions),
+                        sp.GetRequiredService<IOptionsMonitor<LogRecordExportProcessorOptions>>().Get(name),
+                        sp.GetRequiredService<IOptionsMonitor<SdkLimitOptions>>().CurrentValue,
+                        sp.GetRequiredService<IOptionsMonitor<ExperimentalOptions>>().Get(name)));
+            });
+
+        builder.Services.ConfigureOpenTelemetryMeterProvider(
+            (sp, metrics) =>
+            {
+                var builderOptions = GetOptions(sp, name);
+
+                if (!builderOptions.AddToMeterProvider)
+                {
+                    return;
+                }
+
+                metrics.AddReader(
+                    OtlpMetricExporterExtensions.BuildOtlpExporterMetricReader(
+                        OtlpExporterOptions.Merge(builderOptions.DefaultOptions, builderOptions.MetricsOptions),
+                        sp.GetRequiredService<IOptionsMonitor<MetricReaderOptions>>().Get(name),
+                        sp));
+            });
+
+        builder.Services.ConfigureOpenTelemetryTracerProvider(
+            (sp, tracing) =>
+            {
+                var builderOptions = GetOptions(sp, name);
+
+                if (!builderOptions.AddToTracerProvider)
+                {
+                    return;
+                }
+
+                tracing.AddProcessor(
+                    OtlpTraceExporterHelperExtensions.BuildOtlpExporterProcessor(
+                        OtlpExporterOptions.Merge(builderOptions.DefaultOptions, builderOptions.TracingOptions),
+                        sp.GetRequiredService<IOptionsMonitor<SdkLimitOptions>>().CurrentValue,
+                        sp));
+            });
+
+        return builder;
+
+        static OtlpExporterBuilderOptions GetOptions(IServiceProvider sp, string name)
+        {
+            return sp.GetRequiredService<IOptionsMonitor<OtlpExporterBuilderOptions>>().Get(name);
+        }
+    }
+}

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpExporterBuilderOptions.cs

@@ -0,0 +1,82 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#nullable enable
+
+using Microsoft.Extensions.Configuration;
+using OpenTelemetry.Exporter;
+using OpenTelemetry.Internal;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry;
+
+public sealed class OtlpExporterBuilderOptions
+{
+    internal OtlpExporterBuilderOptions(
+        IConfiguration configuration,
+        ActivityExportProcessorOptions defaultExportProcessorOptions)
+    {
+        this.DefaultOptions = new OtlpExporterOptions(configuration, defaultExportProcessorOptions);
+
+        var emptyConfiguration = new ConfigurationBuilder().Build();
+
+        this.LoggingOptions = new OtlpExporterOptions(emptyConfiguration, defaultExportProcessorOptions: null);
+
+        this.MetricsOptions = new OtlpExporterOptions(emptyConfiguration, defaultExportProcessorOptions: null);
+
+        this.TracingOptions = new OtlpExporterOptions(emptyConfiguration, defaultExportProcessorOptions);
+
+        if (configuration.TryGetUriValue("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT", out var endpoint))
+        {
+            this.LoggingOptions.Endpoint = endpoint;
+        }
+
+        if (configuration.TryGetValue<OtlpExportProtocol>(
+            "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL",
+            OtlpExportProtocolParser.TryParse,
+            out var protocol))
+        {
+            this.LoggingOptions.Protocol = protocol;
+        }
+
+        if (configuration.TryGetUriValue("OTEL_EXPORTER_OTLP_METRICS_ENDPOINT", out endpoint))
+        {
+            this.MetricsOptions.Endpoint = endpoint;
+        }
+
+        if (configuration.TryGetValue(
+            "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL",
+            OtlpExportProtocolParser.TryParse,
+            out protocol))
+        {
+            this.MetricsOptions.Protocol = protocol;
+        }
+
+        if (configuration.TryGetUriValue("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", out endpoint))
+        {
+            this.TracingOptions.Endpoint = endpoint;
+        }
+
+        if (configuration.TryGetValue(
+            "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL",
+            OtlpExportProtocolParser.TryParse,
+            out protocol))
+        {
+            this.TracingOptions.Protocol = protocol;
+        }
+    }
+
+    public bool AddToLoggerProvider { get; set; } = true;
+
+    public bool AddToMeterProvider { get; set; } = true;
+
+    public bool AddToTracerProvider { get; set; } = true;
+
+    public OtlpExporterOptions DefaultOptions { get; }
+
+    public OtlpExporterOptions LoggingOptions { get; }
+
+    public OtlpExporterOptions MetricsOptions { get; }
+
+    public OtlpExporterOptions TracingOptions { get; }
+}

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpExporterOptions.cs

@@ -1,6 +1,8 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+#nullable enable
+
 using System.Diagnostics;
 using System.Reflection;
 #if NETFRAMEWORK
@@ -39,22 +41,27 @@ public class OtlpExporterOptions
     private const OtlpExportProtocol DefaultOtlpExportProtocol = OtlpExportProtocol.Grpc;
     private const string UserAgentProduct = "OTel-OTLP-Exporter-Dotnet";
 
-    private Uri endpoint;
+    private Uri? endpoint;
+    private OtlpExportProtocol? protocol;
+    private int? timeoutMilliseconds;
+    private ExportProcessorType? exportProcessorType;
+    private ActivityExportProcessorOptions? defaultProcessorOptions;
+    private BatchExportProcessorOptions<Activity>? batchExportProcessorOptions;
+    private Func<HttpClient>? httpClientFactory;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="OtlpExporterOptions"/> class.
     /// </summary>
     public OtlpExporterOptions()
-        : this(new ConfigurationBuilder().AddEnvironmentVariables().Build(), new())
+        : this(new ConfigurationBuilder().AddEnvironmentVariables().Build(), defaultExportProcessorOptions: null)
     {
     }
 
     internal OtlpExporterOptions(
         IConfiguration configuration,
-        BatchExportActivityProcessorOptions defaultBatchOptions)
+        ActivityExportProcessorOptions? defaultExportProcessorOptions)
     {
         Debug.Assert(configuration != null, "configuration was null");
-        Debug.Assert(defaultBatchOptions != null, "defaultBatchOptions was null");
 
         if (configuration.TryGetUriValue(EndpointEnvVarName, out var endpoint))
         {
@@ -79,15 +86,15 @@ internal OtlpExporterOptions(
             this.Protocol = protocol;
         }
 
-        this.HttpClientFactory = this.DefaultHttpClientFactory = () =>
+        this.DefaultHttpClientFactory = () =>
         {
             return new HttpClient
             {
                 Timeout = TimeSpan.FromMilliseconds(this.TimeoutMilliseconds),
             };
         };
 
-        this.BatchExportProcessorOptions = defaultBatchOptions;
+        this.defaultProcessorOptions = defaultExportProcessorOptions;
     }
 
     /// <summary>
@@ -122,29 +129,54 @@ public Uri Endpoint
     /// Gets or sets optional headers for the connection. Refer to the <a href="https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/exporter.md#specifying-headers-via-environment-variables">
     /// specification</a> for information on the expected format for Headers.
     /// </summary>
-    public string Headers { get; set; }
+    public string? Headers { get; set; }
 
     /// <summary>
     /// Gets or sets the max waiting time (in milliseconds) for the backend to process each batch. The default value is 10000.
     /// </summary>
-    public int TimeoutMilliseconds { get; set; } = 10000;
+    public int TimeoutMilliseconds
+    {
+        get => this.timeoutMilliseconds ?? 10000;
+        set => this.timeoutMilliseconds = value;
+    }
 
     /// <summary>
     /// Gets or sets the the OTLP transport protocol. Supported values: Grpc and HttpProtobuf.
     /// </summary>
-    public OtlpExportProtocol Protocol { get; set; } = DefaultOtlpExportProtocol;
+    public OtlpExportProtocol Protocol
+    {
+        get => this.protocol ?? DefaultOtlpExportProtocol;
+        set => this.protocol = value;
+    }
 
     /// <summary>
     /// Gets or sets the export processor type to be used with the OpenTelemetry Protocol Exporter. The default value is <see cref="ExportProcessorType.Batch"/>.
     /// </summary>
     /// <remarks>Note: This only applies when exporting traces.</remarks>
-    public ExportProcessorType ExportProcessorType { get; set; } = ExportProcessorType.Batch;
+    public ExportProcessorType ExportProcessorType
+    {
+        get => this.defaultProcessorOptions?.ExportProcessorType ?? ExportProcessorType.Batch;
+        set => (this.defaultProcessorOptions ??= new()).ExportProcessorType = value;
+    }
 
     /// <summary>
     /// Gets or sets the BatchExportProcessor options. Ignored unless ExportProcessorType is Batch.
     /// </summary>
     /// <remarks>Note: This only applies when exporting traces.</remarks>
-    public BatchExportProcessorOptions<Activity> BatchExportProcessorOptions { get; set; }
+    public BatchExportProcessorOptions<Activity> BatchExportProcessorOptions
+    {
+        get
+        {
+            if (this.batchExportProcessorOptions != null)
+            {
+                return this.batchExportProcessorOptions;
+            }
+
+            return (this.defaultProcessorOptions ??= new()).BatchExportProcessorOptions;
+        }
+
+        set => this.batchExportProcessorOptions = value;
+    }
 
     /// <summary>
     /// Gets or sets the factory function called to create the <see
@@ -177,7 +209,19 @@ public Uri Endpoint
     /// directly.</item>
     /// </list>
     /// </remarks>
-    public Func<HttpClient> HttpClientFactory { get; set; }
+    public Func<HttpClient> HttpClientFactory
+    {
+        get => this.httpClientFactory ??= this.DefaultHttpClientFactory;
+        set
+        {
+            this.httpClientFactory = value ?? NullHttpClientFactory;
+
+            static HttpClient NullHttpClientFactory()
+            {
+                return null!;
+            }
+        }
+    }
 
     /// <summary>
     /// Gets a value indicating whether <see cref="Endpoint" /> was modified via its setter.
@@ -195,14 +239,57 @@ internal static OtlpExporterOptions CreateOtlpExporterOptions(
         string name)
         => new(
             configuration,
-            serviceProvider.GetRequiredService<IOptionsMonitor<BatchExportActivityProcessorOptions>>().Get(name));
+            serviceProvider.GetRequiredService<IOptionsMonitor<ActivityExportProcessorOptions>>().Get(name));
+
+    internal static OtlpExporterOptions Merge(OtlpExporterOptions defaultInstance, OtlpExporterOptions signalInstance)
+    {
+        if (signalInstance.protocol == null)
+        {
+            signalInstance.protocol = defaultInstance.protocol;
+        }
+
+        if (signalInstance.endpoint == null)
+        {
+            signalInstance.endpoint = defaultInstance.endpoint;
+
+            // Note: We don't set ProgrammaticallyModifiedEndpoint because we
+            // want to append the signal to the default endpoint.
+        }
+
+        if (signalInstance.Headers == null)
+        {
+            signalInstance.Headers = defaultInstance.Headers;
+        }
+
+        if (!signalInstance.timeoutMilliseconds.HasValue)
+        {
+            signalInstance.timeoutMilliseconds = defaultInstance.timeoutMilliseconds;
+        }
+
+        if (!signalInstance.exportProcessorType.HasValue)
+        {
+            signalInstance.exportProcessorType = defaultInstance.exportProcessorType;
+        }
+
+        if (signalInstance.defaultProcessorOptions == null)
+        {
+            signalInstance.defaultProcessorOptions = defaultInstance.defaultProcessorOptions;
+        }
+
+        if (signalInstance.httpClientFactory == null)
+        {
+            signalInstance.httpClientFactory = defaultInstance.httpClientFactory;
+        }
+
+        return signalInstance;
+    }
 
     private static string GetUserAgentString()
     {
         try
         {
             var assemblyVersion = typeof(OtlpExporterOptions).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
-            var informationalVersion = assemblyVersion.InformationalVersion;
+            var informationalVersion = assemblyVersion?.InformationalVersion;
             return string.IsNullOrEmpty(informationalVersion) ? UserAgentProduct : $"{UserAgentProduct}/{informationalVersion}";
         }
         catch (Exception)