Make SerilogLoggerProvider implement IAsyncDisposable on .NET 6 or later.

Author: agehrke

src/Serilog.Extensions.Logging/Extensions/Logging/SerilogLoggerProvider.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Serilog.Core;
 using Serilog.Events;
@@ -14,13 +15,19 @@ namespace Serilog.Extensions.Logging;
 /// </summary>
 [ProviderAlias("Serilog")]
 public class SerilogLoggerProvider : ILoggerProvider, ILogEventEnricher, ISupportExternalScope
+#if NET6_0_OR_GREATER
+    , IAsyncDisposable
+#endif
 {
     internal const string OriginalFormatPropertyName = "{OriginalFormat}";
     internal const string ScopePropertyName = "Scope";
 
     // May be null; if it is, Log.Logger will be lazily used
     readonly ILogger? _logger;
     readonly Action? _dispose;
+#if NET6_0_OR_GREATER
+    readonly Func<ValueTask>? _disposeAsync;
+#endif
     private IExternalScopeProvider? _externalScopeProvider;
 
     /// <summary>
@@ -36,9 +43,25 @@ public SerilogLoggerProvider(ILogger? logger = null, bool dispose = false)
         if (dispose)
         {
             if (logger != null)
+            {
                 _dispose = () => (logger as IDisposable)?.Dispose();
+#if NET6_0_OR_GREATER
+                _disposeAsync = () =>
+                {
+                    // Dispose via IAsyncDisposable if possible, otherwise fall back to IDisposable
+                    if (logger is IAsyncDisposable asyncDisposable) return asyncDisposable.DisposeAsync();
+                    else (logger as IDisposable)?.Dispose();
+                    return default;
+                };
+#endif
+            }
             else
+            {
                 _dispose = Log.CloseAndFlush;
+#if NET6_0_OR_GREATER
+                _disposeAsync = Log.CloseAndFlushAsync;
+#endif
+            }
         }
     }
 
@@ -113,4 +136,12 @@ public void Dispose()
     {
         _dispose?.Invoke();
     }
+
+#if NET6_0_OR_GREATER
+    /// <inheritdoc />
+    public ValueTask DisposeAsync()
+    {
+        return _disposeAsync?.Invoke() ?? default;
+    }
+#endif
 }

test/Serilog.Extensions.Logging.Tests/DisposeTests.cs

@@ -0,0 +1,72 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Serilog.Core;
+using Serilog.Events;
+using Xunit;
+
+namespace Serilog.Extensions.Logging.Tests;
+
+public class DisposeTests
+{
+    private readonly DisposableSink _sink;
+    private readonly Logger _serilogLogger;
+
+    public DisposeTests()
+    {
+        _sink = new DisposableSink();
+        _serilogLogger = new LoggerConfiguration()
+            .WriteTo.Sink(_sink)
+            .CreateLogger();
+    }
+
+    [Fact]
+    public void AddSerilog_must_dispose_the_provider_when_dispose_is_true()
+    {
+        var services = new ServiceCollection()
+            .AddLogging(builder => builder.AddSerilog(logger: _serilogLogger, dispose: true))
+            .BuildServiceProvider();
+
+        // Get a logger so that we ensure SerilogLoggerProvider is created
+        var logger = services.GetRequiredService<ILogger<DisposeTests>>();
+        logger.LogInformation("Hello, world!");
+
+        services.Dispose();
+        Assert.True(_sink.DisposeCalled);
+        Assert.False(_sink.DisposeAsyncCalled);
+    }
+
+#if NET8_0_OR_GREATER
+    [Fact]
+    public async Task AddSerilog_must_async_dispose_the_provider_when_dispose_is_true()
+    {
+      var services = new ServiceCollection()
+            .AddLogging(builder => builder.AddSerilog(logger: _serilogLogger, dispose: true))
+            .BuildServiceProvider();
+
+        // Get a logger so that we ensure SerilogLoggerProvider is created
+        var logger = services.GetRequiredService<ILogger<DisposeTests>>();
+        logger.LogInformation("Hello, world!");
+
+        await services.DisposeAsync();
+        Assert.False(_sink.DisposeCalled);
+        Assert.True(_sink.DisposeAsyncCalled);
+    }
+#endif
+
+    private sealed class DisposableSink : ILogEventSink, IDisposable, IAsyncDisposable
+    {
+        public bool DisposeAsyncCalled { get; private set; }
+        public bool DisposeCalled { get; private set; }
+
+        public void Dispose() => DisposeCalled = true;
+        public ValueTask DisposeAsync()
+        {
+            DisposeAsyncCalled = true;
+            return default;
+        }
+
+        public void Emit(LogEvent logEvent)
+        {
+        }
+    }
+}