Add otlp log extension methods for LoggerProviderBuilder

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpLogExporterHelperExtensions.cs

@@ -14,8 +14,13 @@
 // limitations under the License.
 // </copyright>
 
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using OpenTelemetry.Exporter;
+using OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation;
+using OpenTelemetry.Internal;
+using System.Diagnostics;
 
 namespace OpenTelemetry.Logs;
 
@@ -45,14 +50,197 @@
         => AddOtlpExporterInternal(loggerOptions, configure);
 
     /// <summary>
-    /// Adds an OTLP Exporter to the OpenTelemetry <see cref="ILoggerProvider"/>.
+    /// Adds OpenTelemetry Protocol (OTLP) exporter to the LoggerProvider.
     /// </summary>
-    /// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> options to use.</param>
-    /// <param name="configureExporterAndProcessor">Callback action for configuring <see cref="OtlpExporterOptions"/> and <see cref="LogRecordExportProcessorOptions"/>.</param>
-    /// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
-    public static OpenTelemetryLoggerOptions AddOtlpExporter(
-        this OpenTelemetryLoggerOptions loggerOptions,
+    /// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
+    /// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
+    public static LoggerProviderBuilder AddOtlpExporter(this LoggerProviderBuilder builder)
+           => AddOtlpExporter(builder, name: null, configureExporter: null);
+
+    /// <summary>
+    /// Adds OpenTelemetry Protocol (OTLP) exporter to the LoggerProvider.
+    /// </summary>
+    /// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
+    /// <param name="configureExporter">Callback action for configuring <see cref="OtlpExporterOptions"/>.</param>
+    /// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
+    public static LoggerProviderBuilder AddOtlpExporter(this LoggerProviderBuilder builder, Action<OtlpExporterOptions> configureExporter)
+     => AddOtlpExporter(builder, name: null, configureExporter: configureExporter);
+
+    /// <summary>
+    /// Adds OpenTelemetry Protocol (OTLP) exporter to the LoggerProvider.
+    /// </summary>
+    /// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
+    /// <param name="configureExporterAndProcessor">Callback action for
+    /// configuring <see cref="OtlpExporterOptions"/> and <see
+    /// cref="LogRecordExportProcessorOptions"/>.</param>
+    /// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
+    public static LoggerProviderBuilder AddOtlpExporter(this LoggerProviderBuilder builder, Action<OtlpExporterOptions, LogRecordExportProcessorOptions> configureExporterAndProcessor)
+     => AddOtlpExporter(builder, name: null, configureExporterAndProcessor: configureExporterAndProcessor);
+
+    /// <summary>
+    /// Adds OpenTelemetry Protocol (OTLP) exporter to the LoggerProvider.
+    /// </summary>
+    /// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
+    /// <param name="name">Name which is used when retrieving options.</param>
+    /// <param name="configureExporter">Callback action for configuring <see cref="OtlpExporterOptions"/>.</param>
+    /// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
+    public static LoggerProviderBuilder AddOtlpExporter(
+        this LoggerProviderBuilder builder,
+        string name,
+        Action<OtlpExporterOptions> configureExporter)
+    {
+        var finalOptionsName = name ?? Options.DefaultName;
+
+        builder.ConfigureServices(services =>
+        {
+            if (name != null && configureExporter != null)
+            {
+                // If we are using named options we register the
+                // configuration delegate into options pipeline.
+                services.Configure(finalOptionsName, configureExporter);
+            }
+
+            OtlpExporterOptions.RegisterOtlpExporterOptionsFactory(services);
+            services.RegisterOptionsFactory(configuration => new SdkLimitOptions(configuration));
+        });
+
+        return builder.AddProcessor(sp =>
+        {
+            OtlpExporterOptions exporterOptions;
+
+            if (name == null)
+            {
+                // If we are NOT using named options we create a new
+                // instance always. The reason for this is
+                // OtlpExporterOptions is shared by all signals. Without a
+                // name, delegates for all signals will mix together. See:
+                // https://github.com/open-telemetry/opentelemetry-dotnet/issues/4043
+                exporterOptions = sp.GetRequiredService<IOptionsFactory<OtlpExporterOptions>>().Create(finalOptionsName);
+
+                // Configuration delegate is executed inline on the fresh instance.
+                configureExporter?.Invoke(exporterOptions);
+            }
+            else
+            {
+                // When using named options we can properly utilize Options
+                // API to create or reuse an instance.
+                exporterOptions = sp.GetRequiredService<IOptionsMonitor<OtlpExporterOptions>>().Get(finalOptionsName);
+            }
+
+            // Note: Not using finalOptionsName here for SdkLimitOptions.
+            // There should only be one provider for a given service
+            // collection so SdkLimitOptions is treated as a single default
+            // instance.
+            var sdkOptionsManager = sp.GetRequiredService<IOptionsMonitor<SdkLimitOptions>>().CurrentValue;
+
+            return BuildOtlpLogExporterProcessor(
+                exporterOptions,
+                sp.GetRequiredService<IOptionsMonitor<LogRecordExportProcessorOptions>>().Get(finalOptionsName),
+                sdkOptionsManager,
+                sp);
+        });
+    }
+
+    /// <summary>
+    /// Adds OpenTelemetry Protocol (OTLP) exporter to the LoggerProvider.
+    /// </summary>
+    /// <param name="builder"><see cref="LoggerProviderBuilder"/> builder to use.</param>
+    /// <param name="name">Name which is used when retrieving options.</param>
+    /// <param name="configureExporterAndProcessor">Callback action for
+    /// configuring <see cref="OtlpExporterOptions"/> and <see
+    /// cref="LogRecordExportProcessorOptions"/>.</param>
+    /// <returns>The instance of <see cref="LoggerProviderBuilder"/> to chain the calls.</returns>
+    public static LoggerProviderBuilder AddOtlpExporter(
+        this LoggerProviderBuilder builder,
+        string name,
         Action<OtlpExporterOptions, LogRecordExportProcessorOptions> configureExporterAndProcessor)
+    {
+        var finalOptionsName = name ?? Options.DefaultName;
+
+        builder.ConfigureServices(services =>
+        {
+            OtlpExporterOptions.RegisterOtlpExporterOptionsFactory(services);
+            services.RegisterOptionsFactory(configuration => new SdkLimitOptions(configuration));
+        });
+
+        return builder.AddProcessor(sp =>
+        {
+            OtlpExporterOptions exporterOptions;
+            LogRecordExportProcessorOptions processorOptions;
+
+            if (name == null)
+            {
+                // If we are NOT using named options we create a new
+                // instance always. The reason for this is
+                // OtlpExporterOptions is shared by all signals. Without a
+                // name, delegates for all signals will mix together. See:
+                // https://github.com/open-telemetry/opentelemetry-dotnet/issues/4043
+                exporterOptions = sp.GetRequiredService<IOptionsFactory<OtlpExporterOptions>>().Create(finalOptionsName);
+                processorOptions = sp.GetRequiredService<IOptionsFactory<LogRecordExportProcessorOptions>>().Create(finalOptionsName);
+
+                // Configuration delegate is executed inline on the fresh instance.
+                configureExporterAndProcessor?.Invoke(exporterOptions, processorOptions);
+            }
+            else
+            {
+                // When using named options we can properly utilize Options
+                // API to create or reuse an instance.
+                exporterOptions = sp.GetRequiredService<IOptionsMonitor<OtlpExporterOptions>>().Get(finalOptionsName);
+                processorOptions = sp.GetRequiredService<IOptionsMonitor<LogRecordExportProcessorOptions>>().Get(finalOptionsName);
+            }
+
+            // Note: Not using finalOptionsName here for SdkLimitOptions.
+            // There should only be one provider for a given service
+            // collection so SdkLimitOptions is treated as a single default
+            // instance.
+            var sdkOptionsManager = sp.GetRequiredService<IOptionsMonitor<SdkLimitOptions>>().CurrentValue;
+
+            return BuildOtlpLogExporterProcessor(
+                exporterOptions,
+                processorOptions,
+                sdkOptionsManager,
+                sp);
+        });
+    }
+
+    private static BaseProcessor<LogRecord> BuildOtlpLogExporterProcessor(OtlpExporterOptions exporterOptions, LogRecordExportProcessorOptions processorOptions, SdkLimitOptions sdkLimitOptions, IServiceProvider sp)
+    {
+        /*
+         * Note:
+         *
+         * We don't currently enable IHttpClientFactory for OtlpLogExporter.
+         *
+         * The DefaultHttpClientFactory requires the ILoggerFactory in its ctor:
+         * https://github.com/dotnet/runtime/blob/fa40ecf7d36bf4e31d7ae968807c1c529bac66d6/src/libraries/Microsoft.Extensions.Http/src/DefaultHttpClientFactory.cs#L64
+         *
+         * This creates a circular reference: ILoggerFactory ->
+         * OpenTelemetryLoggerProvider -> OtlpLogExporter -> IHttpClientFactory
+         * -> ILoggerFactory
+         *
+         * exporterOptions.TryEnableIHttpClientFactoryIntegration(sp,
+         * "OtlpLogExporter");
+         */
+
+        BaseExporter<LogRecord> otlpExporter = new OtlpLogExporter(exporterOptions, sdkLimitOptions);
+
+        if (processorOptions.ExportProcessorType == ExportProcessorType.Simple)
+        {
+            return new SimpleLogRecordExportProcessor(otlpExporter);
+        }
+        else
+        {
+            return new BatchLogRecordExportProcessor(
+                otlpExporter,
+                processorOptions.BatchExportProcessorOptions.MaxQueueSize,
+                processorOptions.BatchExportProcessorOptions.ScheduledDelayMilliseconds,
+                processorOptions.BatchExportProcessorOptions.ExporterTimeoutMilliseconds,
+                processorOptions.BatchExportProcessorOptions.MaxExportBatchSize);
+        }
+    }
+
+    private static OpenTelemetryLoggerOptions AddOtlpExporterInternal(
+        OpenTelemetryLoggerOptions loggerOptions,
+        Action<OtlpExporterOptions> configure)
     {
         var exporterOptions = new OtlpExporterOptions();
         var processorOptions = new LogRecordExportProcessorOptions();
@@ -91,7 +279,7 @@
         }
     }
 
     private static OpenTelemetryLoggerOptions AddOtlpExporterInternal(
     OpenTelemetryLoggerOptions loggerOptions,
     Action<OtlpExporterOptions> configure)
     {

src/OpenTelemetry.Extensions.Hosting/OpenTelemetryBuilder.cs

@@ -190,7 +190,7 @@ OpenTelemetryBuilder WithLogging(Action<LoggerProviderBuilder> configure)
     {
         Guard.ThrowIfNull(configure);
 
-        var builder = new LoggerProviderBuilderBase(this.Services);
+        var builder = new LoggerProviderBuilderBase(this.Services, addSharedServices: false);
 
         configure(builder);
 

src/OpenTelemetry/Logs/Builder/LoggerProviderBuilderBase.cs

@@ -46,10 +46,21 @@ public LoggerProviderBuilderBase()
         this.allowBuild = true;
     }
 
-    internal LoggerProviderBuilderBase(IServiceCollection services)
+    internal LoggerProviderBuilderBase(IServiceCollection services, bool addSharedServices)
     {
         Guard.ThrowIfNull(services);
 
+        if (addSharedServices)
+        {
+            /* Note: This ensures IConfiguration is available when using
+             * IServiceCollections NOT attached to a host. For example when
+             * performing:
+             *
+             * new ServiceCollection().AddLogging(b => b.AddOpenTelemetry())
+            */
+            services.AddOpenTelemetrySharedProviderBuilderServices();
+        }
+
         services
             .AddOpenTelemetryLoggerProviderBuilderServices()
             .TryAddSingleton<LoggerProvider>(sp => new LoggerProviderSdk(sp, ownsServiceProvider: false));

src/OpenTelemetry/Logs/ILogger/OpenTelemetryLoggingExtensions.cs

@@ -14,6 +14,9 @@
 // limitations under the License.
 // </copyright>
 
+#nullable enable
+
+using System.Diagnostics;
 #if NET6_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
 #endif
@@ -58,7 +61,7 @@ public static ILoggingBuilder AddOpenTelemetry(
         // Note: This will bind logger options element (eg "Logging:OpenTelemetry") to OpenTelemetryLoggerOptions
         RegisterLoggerProviderOptions(builder.Services);
 
-        new LoggerProviderBuilderBase(builder.Services).ConfigureBuilder(
+        new LoggerProviderBuilderBase(builder.Services, addSharedServices: true).ConfigureBuilder(
             (sp, logging) =>
             {
                 var options = sp.GetRequiredService<IOptionsMonitor<OpenTelemetryLoggerOptions>>().CurrentValue;
@@ -80,10 +83,40 @@ public static ILoggingBuilder AddOpenTelemetry(
 
         builder.Services.TryAddEnumerable(
             ServiceDescriptor.Singleton<ILoggerProvider, OpenTelemetryLoggerProvider>(
-                sp => new OpenTelemetryLoggerProvider(
-                    sp.GetRequiredService<LoggerProvider>(),
-                    sp.GetRequiredService<IOptionsMonitor<OpenTelemetryLoggerOptions>>().CurrentValue,
-                    disposeProvider: false)));
+                sp =>
+                {
+                    var state = sp.GetRequiredService<LoggerProviderBuilderSdk>();
+
+                    var provider = state.Provider;
+                    if (provider == null)
+                    {
+                        /*
+                         * Note:
+                         *
+                         * There is the possibility of a circular reference when
+                         * accessing LoggerProvider from the IServiceProvider.
+                         *
+                         * If LoggerProvider is the first thing accessed and it
+                         * requires some service which accesses ILogger (for
+                         * example IHttpClientFactory) than the
+                         * OpenTelemetryLoggerProvider will try to access the
+                         * LoggerProvider inside the initial access to
+                         * LoggerProvider.
+                         *
+                         * This check uses the provider reference captured on
+                         * LoggerProviderBuilderSdk during construction of
+                         * LoggerProviderSdk to detect if a provider has already
+                         * been created to give to OpenTelemetryLoggerProvider.
+                        */
+                        provider = sp.GetRequiredService<LoggerProvider>();
+                        Debug.Assert(provider == state.Provider, "state.Provider did not match resolved LoggerProvider");
+                    }
+
+                    return new OpenTelemetryLoggerProvider(
+                        provider,
+                        sp.GetRequiredService<IOptionsMonitor<OpenTelemetryLoggerOptions>>().CurrentValue,
+                        disposeProvider: false);
+                }));
 
         return builder;