make use of lightweight LoggingSinkConfiguration.Wrap(..)

Author: Sergey Komisarchik

src/Serilog.Sinks.Async/LoggerConfigurationAsyncExtensions.cs

@@ -1,6 +1,6 @@
 using System;
 using Serilog.Configuration;
-using Serilog.Events;
+
 using Serilog.Sinks.Async;
 
 namespace Serilog
@@ -24,14 +24,10 @@ public static LoggerConfiguration Async(
             Action<LoggerSinkConfiguration> configure,
             int bufferSize = 10000)
         {
-            var sublogger = new LoggerConfiguration();
-            sublogger.MinimumLevel.Is(LevelAlias.Minimum);
-
-            configure(sublogger.WriteTo);
-
-            var wrapper = new BackgroundWorkerSink(sublogger.CreateLogger(), bufferSize);
-
-            return loggerSinkConfiguration.Sink(wrapper);
+            return LoggerSinkConfiguration.Wrap(
+                loggerSinkConfiguration,
+                wrappedSink => new BackgroundWorkerSink(wrappedSink, bufferSize),
+                configure);
         }
     }
 }

src/Serilog.Sinks.Async/Serilog.Sinks.Async.csproj

@@ -23,7 +23,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Serilog" Version="2.1.0" />
+    <PackageReference Include="Serilog" Version="2.5.0" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net45' ">

src/Serilog.Sinks.Async/Sinks/Async/BackgroundWorkerSink.cs

@@ -10,14 +10,14 @@ namespace Serilog.Sinks.Async
 {
     sealed class BackgroundWorkerSink : ILogEventSink, IDisposable
     {
-        readonly Logger _pipeline;
+        readonly ILogEventSink _pipeline;
         readonly int _bufferCapacity;
         volatile bool _disposed;
         readonly CancellationTokenSource _cancel = new CancellationTokenSource();
         readonly BlockingCollection<LogEvent> _queue;
         readonly Task _worker;
 
-        public BackgroundWorkerSink(Logger pipeline, int bufferCapacity)
+        public BackgroundWorkerSink(ILogEventSink pipeline, int bufferCapacity)
         {
             if (pipeline == null) throw new ArgumentNullException(nameof(pipeline));
             if (bufferCapacity <= 0) throw new ArgumentOutOfRangeException(nameof(bufferCapacity));
@@ -40,7 +40,7 @@ public void Dispose()
             _disposed = true;
             _cancel.Cancel();
             _worker.Wait();            
-            _pipeline.Dispose();
+            (_pipeline as IDisposable)?.Dispose();
             // _cancel not disposed, because it will make _cancel.Cancel() non-idempotent
         }
 
@@ -53,14 +53,14 @@ void Pump()
                     while (true)
                     {
                         var next = _queue.Take(_cancel.Token);
-                        _pipeline.Write(next);
+                        _pipeline.Emit(next);
                     }
                 }
                 catch (OperationCanceledException)
                 {
                     LogEvent next;
                     while (_queue.TryTake(out next))
-                        _pipeline.Write(next);
+                        _pipeline.Emit(next);
                 }
             }
             catch (Exception ex)