Fix lazy logger provider retry after failed build

src/OpenTelemetry/Logs/Builder/LoggerProviderBuilderSdk.cs

@@ -39,6 +39,14 @@ public void RegisterProvider(LoggerProviderSdk loggerProvider)
         this.loggerProvider = loggerProvider;
     }
 
+    public void UnregisterProvider(LoggerProviderSdk loggerProvider)
+    {
+        if (ReferenceEquals(this.loggerProvider, loggerProvider))
+        {
+            this.loggerProvider = null;
+        }
+    }
+
     public override LoggerProviderBuilder AddInstrumentation<TInstrumentation>(Func<TInstrumentation> instrumentationFactory)
     {
         var instance = instrumentationFactory();

src/OpenTelemetry/Logs/LoggerProviderSdk.cs

@@ -79,6 +79,7 @@ public LoggerProviderSdk(
         }
         catch (Exception)
         {
+            state.UnregisterProvider(this);
             this.DisposeBuiltState(state);
             throw;
         }

test/OpenTelemetry.Tests/Logs/OpenTelemetryLoggingExtensionsTests.cs

@@ -303,6 +303,44 @@ public void CircularReferenceTest(bool requestLoggerProviderDirectly)
         Assert.IsType<TestLogProcessorWithILoggerFactoryDependency>(loggerProvider.Processor);
     }
 
+    [Fact]
+    public void LazyProviderRetriesAfterFailedBuildTest()
+    {
+        var configureInvocationCount = 0;
+        TestLogProcessor? configuredProcessor = null;
+        var services = new ServiceCollection();
+
+        services.AddLogging(logging => logging.AddOpenTelemetry());
+
+        services.ConfigureOpenTelemetryLoggerProvider((sp, builder) =>
+        {
+            if (Interlocked.Increment(ref configureInvocationCount) == 1)
+            {
+                throw new InvalidOperationException("The first logger provider build is expected to fail.");
+            }
+
+            configuredProcessor = new TestLogProcessor();
+            builder.AddProcessor(configuredProcessor);
+        });
+
+        using var serviceProvider = services.BuildServiceProvider();
+        var loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
+
+        Assert.Throws<InvalidOperationException>(() => loggerFactory.CreateLogger("FirstLogger"));
+
+        var logger = loggerFactory.CreateLogger("SecondLogger");
+        logger.Log(
+            LogLevel.Information,
+            new EventId(1),
+            "This record should be processed.",
+            exception: null,
+            static (state, _) => state);
+
+        var processor = Assert.IsType<TestLogProcessor>(configuredProcessor);
+        Assert.Equal(2, configureInvocationCount);
+        Assert.Equal(1, processor.OnEndCount);
+    }
+
     [Theory]
     [InlineData(true, false)]
     [InlineData(false, true)]
@@ -388,6 +426,15 @@ private sealed class TestLogProcessor : BaseProcessor<LogRecord>
     {
         public bool Disposed;
 
+        public int OnEndCount;
+
+        public override void OnEnd(LogRecord data)
+        {
+            this.OnEndCount++;
+
+            base.OnEnd(data);
+        }
+
         protected override void Dispose(bool disposing)
         {
             this.Disposed = true;