[hosting-logs] Add WithLogging

src/OpenTelemetry.Api/AssemblyInfo.cs

@@ -20,6 +20,8 @@
 [assembly: InternalsVisibleTo("OpenTelemetry.Api.ProviderBuilderExtensions" + AssemblyInfo.PublicKey)]
 [assembly: InternalsVisibleTo("OpenTelemetry.Api.ProviderBuilderExtensions.Tests" + AssemblyInfo.PublicKey)]
 [assembly: InternalsVisibleTo("OpenTelemetry.Api.Tests" + AssemblyInfo.PublicKey)]
+[assembly: InternalsVisibleTo("OpenTelemetry.Extensions.Hosting" + AssemblyInfo.PublicKey)]
+[assembly: InternalsVisibleTo("OpenTelemetry.Extensions.Hosting.Tests" + AssemblyInfo.PublicKey)]
 [assembly: InternalsVisibleTo("OpenTelemetry.Shims.OpenTracing.Tests" + AssemblyInfo.PublicKey)]
 [assembly: InternalsVisibleTo("OpenTelemetry.Tests" + AssemblyInfo.PublicKey)]
 [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2" + AssemblyInfo.MoqPublicKey)]

src/OpenTelemetry.Extensions.Hosting/AssemblyInfo.cs

@@ -19,6 +19,7 @@
 [assembly: InternalsVisibleTo("OpenTelemetry.Extensions.Hosting.Tests" + AssemblyInfo.PublicKey)]
 [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2" + AssemblyInfo.MoqPublicKey)]
 
+/* Note: OpenTelemetry.Extensions.Hosting temporarily sees OpenTelemetry.Api internals for LoggerProvider
 #if SIGNED
 internal static class AssemblyInfo
 {
@@ -32,3 +33,4 @@ internal static class AssemblyInfo
     public const string MoqPublicKey = "";
 }
 #endif
+*/

src/OpenTelemetry.Extensions.Hosting/Implementation/HostingExtensionsEventSource.cs

@@ -37,5 +37,11 @@ public void MeterProviderNotRegistered()
         {
             this.WriteEvent(2);
         }
+
+        [Event(3, Message = "OpenTelemetry LoggerProvider was not found in application services. Logging will remain disabled.", Level = EventLevel.Warning)]
+        public void LoggerProviderNotRegistered()
+        {
+            this.WriteEvent(3);
+        }
     }
 }

src/OpenTelemetry.Extensions.Hosting/Implementation/TelemetryHostedService.cs

@@ -17,6 +17,7 @@
 using System.Diagnostics;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using OpenTelemetry.Logs;
 using OpenTelemetry.Metrics;
 using OpenTelemetry.Trace;
 
@@ -64,5 +65,11 @@ internal static void Initialize(IServiceProvider serviceProvider)
         {
             HostingExtensionsEventSource.Log.TracerProviderNotRegistered();
         }
+
+        var loggerProvider = serviceProvider!.GetService<LoggerProvider>();
+        if (loggerProvider == null)
+        {
+            HostingExtensionsEventSource.Log.LoggerProviderNotRegistered();
+        }
     }
 }

src/OpenTelemetry.Extensions.Hosting/OpenTelemetry.Extensions.Hosting.csproj

@@ -18,8 +18,10 @@
   </ItemGroup>
 
   <ItemGroup>
+    <!-- Note: OpenTelemetry.Extensions.Hosting temporarily sees OpenTelemetry.Api internals for LoggerProvider
     <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\ExceptionExtensions.cs" Link="Includes\ExceptionExtensions.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\Guard.cs" Link="Includes\Guard.cs" />
+    -->
   </ItemGroup>
 
 </Project>

src/OpenTelemetry.Extensions.Hosting/OpenTelemetryBuilder.cs

@@ -15,7 +15,9 @@
 // </copyright>
 
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using OpenTelemetry.Internal;
+using OpenTelemetry.Logs;
 using OpenTelemetry.Metrics;
 using OpenTelemetry.Resources;
 using OpenTelemetry.Trace;
@@ -131,4 +133,45 @@ public OpenTelemetryBuilder WithTracing(Action<TracerProviderBuilder> configure)
 
         return this;
     }
+
+    /// <summary>
+    /// Adds logging services into the builder.
+    /// </summary>
+    /// <remarks>
+    /// Notes:
+    /// <list type="bullet">
+    /// <item>This is safe to be called multiple times and by library authors.
+    /// Only a single <see cref="LoggerProvider"/> will be created for a given
+    /// <see cref="IServiceCollection"/>.</item>
+    /// <item>This operation enables <see cref="ILogger"/> integration
+    /// automatically by calling <see
+    /// cref="OpenTelemetryLoggingExtensions.AddOpenTelemetry(ILoggingBuilder)"/>.</item>
+    /// </list>
+    /// </remarks>
+    /// <returns>The supplied <see cref="OpenTelemetryBuilder"/> for chaining
+    /// calls.</returns>
+    internal OpenTelemetryBuilder WithLogging()
+        => this.WithLogging(b => { });
+
+    /// <summary>
+    /// Adds logging services into the builder.
+    /// </summary>
+    /// <remarks><inheritdoc cref="WithLogging()" path="/remarks"/></remarks>
+    /// <param name="configure"><see cref="LoggerProviderBuilder"/>
+    /// configuration callback.</param>
+    /// <returns>The supplied <see cref="OpenTelemetryBuilder"/> for chaining
+    /// calls.</returns>
+    internal OpenTelemetryBuilder WithLogging(Action<LoggerProviderBuilder> configure)
+    {
+        Guard.ThrowIfNull(configure);
+
+        // Note: This enables ILogger integration
+        this.Services.AddLogging().AddOpenTelemetry();
+
+        var builder = new LoggerProviderServiceCollectionBuilder(this.Services);
+
+        configure(builder);
+
+        return this;
+    }
 }

test/OpenTelemetry.Extensions.Hosting.Tests/OpenTelemetryServicesExtensionsTests.cs

@@ -17,6 +17,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using OpenTelemetry.Logs;
 using OpenTelemetry.Metrics;
 using OpenTelemetry.Trace;
 using Xunit;
@@ -326,6 +327,129 @@ public void AddOpenTelemetry_WithMetrics_NestedResolutionUsingConfigureTest()
         Assert.True(innerTestExecuted);
     }
 
+    [Fact]
+    public void AddOpenTelemetry_WithLogging_SingleProviderForServiceCollectionTest()
+    {
+        var services = new ServiceCollection();
+
+        services.AddOpenTelemetry().WithLogging(builder => { });
+
+        services.AddOpenTelemetry().WithLogging(builder => { });
+
+        using var serviceProvider = services.BuildServiceProvider();
+
+        Assert.NotNull(serviceProvider);
+
+        var tracerProviders = serviceProvider.GetServices<LoggerProvider>();
+
+        Assert.Single(tracerProviders);
+    }
+
+    [Fact]
+    public void AddOpenTelemetry_WithLogging_DisposalTest()
+    {
+        var services = new ServiceCollection();
+
+        bool testRun = false;
+
+        services.AddOpenTelemetry().WithLogging(builder =>
+        {
+            testRun = true;
+
+            // Note: Build can't be called directly on builder tied to external services
+            Assert.Throws<NotSupportedException>(() => builder.Build());
+        });
+
+        Assert.True(testRun);
+
+        var serviceProvider = services.BuildServiceProvider();
+
+        var provider = serviceProvider.GetRequiredService<LoggerProvider>() as LoggerProviderSdk;
+
+        Assert.NotNull(provider);
+        Assert.Null(provider.OwnedServiceProvider);
+
+        Assert.NotNull(serviceProvider);
+        Assert.NotNull(provider);
+
+        Assert.False(provider.Disposed);
+
+        serviceProvider.Dispose();
+
+        Assert.True(provider.Disposed);
+    }
+
+    [Fact]
+    public async Task AddOpenTelemetry_WithLogging_HostConfigurationHonoredTest()
+    {
+        bool configureBuilderCalled = false;
+
+        var builder = new HostBuilder()
+            .ConfigureAppConfiguration(builder =>
+            {
+                builder.AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["TEST_KEY"] = "TEST_KEY_VALUE",
+                });
+            })
+            .ConfigureServices(services =>
+            {
+                services.AddOpenTelemetry()
+                    .WithLogging(builder =>
+                    {
+                        if (builder is IDeferredLoggerProviderBuilder deferredLoggerProviderBuilder)
+                        {
+                            deferredLoggerProviderBuilder.Configure((sp, builder) =>
+                            {
+                                configureBuilderCalled = true;
+
+                                var configuration = sp.GetRequiredService<IConfiguration>();
+
+                                var testKeyValue = configuration.GetValue<string>("TEST_KEY", null);
+
+                                Assert.Equal("TEST_KEY_VALUE", testKeyValue);
+                            });
+                        }
+                    });
+            });
+
+        var host = builder.Build();
+
+        Assert.False(configureBuilderCalled);
+
+        await host.StartAsync().ConfigureAwait(false);
+
+        Assert.True(configureBuilderCalled);
+
+        await host.StopAsync().ConfigureAwait(false);
+
+        host.Dispose();
+    }
+
+    [Fact]
+    public void AddOpenTelemetry_WithLogging_NestedResolutionUsingConfigureTest()
+    {
+        bool innerTestExecuted = false;
+
+        var services = new ServiceCollection();
+
+        services.AddOpenTelemetry().WithLogging(builder =>
+        {
+            if (builder is IDeferredLoggerProviderBuilder deferredLoggerProviderBuilder)
+            {
+                deferredLoggerProviderBuilder.Configure((sp, builder) =>
+                {
+                    innerTestExecuted = true;
+                    Assert.Throws<NotSupportedException>(() => sp.GetService<LoggerProvider>());
+                });
+            }
+        });
+
+        using var serviceProvider = services.BuildServiceProvider();
+        var resolvedProvider = serviceProvider.GetRequiredService<LoggerProvider>();
+        Assert.True(innerTestExecuted);
+    }
+
     private sealed class MySampler : Sampler
     {
         public override SamplingResult ShouldSample(in SamplingParameters samplingParameters)