Refactored InjectableTestOutputSink for teardown safety, preventing hangs and dropped logs.

Added bounded channels, cancellation tokens, and timed disposal for clean, non-blocking shutdown.

Author: soenneker

src/Serilog.Sinks.XUnit.Injectable/Abstract/IInjectableTestOutputSink.cs

@@ -8,11 +8,17 @@
 namespace Serilog.Sinks.XUnit.Injectable.Abstract;
 
 /// <summary>
-/// A sink to direct Serilog output to the XUnit test output via dependency injection <para/>
-/// Use as a Singleton
+/// Serilog sink that writes to xUnit's <see cref="ITestOutputHelper"/> and/or an <see cref="IMessageSink"/>.
+/// Safe to dispose during/after test teardown without hangs. Use as a singleton.
 /// </summary>
 public interface IInjectableTestOutputSink : ILogEventSink, IAsyncDisposable, IDisposable
 {
+    /// <summary>
+    /// Optional early stop; disposing already does this. Call if you want the sink quiet
+    /// before you flush Serilog.
+    /// </summary>
+    void Complete();
+
     /// <summary>
     ///     Call this as soon as you have a new instance of the testOutputHelper (usually at the beginning of a xUnit test
     ///     class)

src/Serilog.Sinks.XUnit.Injectable/InjectableTestOutputSink.cs

@@ -1,125 +1,214 @@
 using Serilog.Events;
 using Serilog.Formatting.Display;
 using Serilog.Sinks.XUnit.Injectable.Abstract;
-using System;
-using System.Collections.Generic;
-using System.Threading.Channels;
-using System.Threading.Tasks;
 using Soenneker.Extensions.Task;
 using Soenneker.Extensions.ValueTask;
 using Soenneker.Utils.AtomicBool;
 using Soenneker.Utils.ReusableStringWriter;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
 using Xunit;
 using Xunit.Sdk;
 using Xunit.v3;
 
 namespace Serilog.Sinks.XUnit.Injectable;
 
-/// <inheritdoc cref="IInjectableTestOutputSink"/>
-public sealed class InjectableTestOutputSink : IInjectableTestOutputSink, IAsyncDisposable, IDisposable
+///<inheritdoc cref="IInjectableTestOutputSink"/>
+public sealed class InjectableTestOutputSink : IInjectableTestOutputSink
 {
     private const string _defaultTemplate = "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{Exception}";
+    private const int _backlogCap = 2048; // limit in-memory backlog when helper isn't available
+    private const int _channelCapacity = 4096; // apply backpressure under heavy logging
+
+    private static readonly TimeSpan _drainWait = TimeSpan.FromSeconds(2);
+    private static readonly TimeSpan _cancelWait = TimeSpan.FromSeconds(3);
 
     private readonly MessageTemplateTextFormatter _fmt;
 
-    private readonly Channel<LogEvent> _ch = Channel.CreateUnbounded<LogEvent>(new UnboundedChannelOptions
-        { SingleReader = true, SingleWriter = false, AllowSynchronousContinuations = false });
+    // Bounded channel prevents infinite growth if tests end or helper is missing.
+    private readonly Channel<LogEvent> _ch = Channel.CreateBounded<LogEvent>(new BoundedChannelOptions(_channelCapacity)
+    {
+        SingleReader = true,
+        SingleWriter = false,
+        FullMode = BoundedChannelFullMode.DropWrite,
+        AllowSynchronousContinuations = false
+    });
 
+    private readonly CancellationTokenSource _cts = new();
     private readonly Task _readerTask;
 
     private readonly ReusableStringWriter _sw = new();
 
-    // Shared with producers/reader – volatile for safe publication
+    // Volatile so producers/reader see latest references without locks
     private volatile ITestOutputHelper? _helper;
     private volatile IMessageSink? _sink;
 
-    // Only the reader touches this; safe without locks.
+    // Only the reader loop touches this queue
     private readonly Queue<LogEvent> _pending = new();
 
     private readonly AtomicBool _disposed = new();
 
     public InjectableTestOutputSink(string outputTemplate = _defaultTemplate, IFormatProvider? formatProvider = null)
     {
         _fmt = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
-        _readerTask = Task.Run(ReadLoop);
+        _readerTask = Task.Run(() => ReadLoop(_cts.Token));
     }
 
-    public void Inject(ITestOutputHelper helper, IMessageSink? sink = null)
+    /// <summary>Inject the current test's output helper (call at test start).</summary>
+    public void Inject(ITestOutputHelper helper, IMessageSink? diagnosticSink = null)
     {
         ArgumentNullException.ThrowIfNull(helper);
-        _helper = helper;
-        _sink = sink;
+        _helper = helper; // publish to reader
+        _sink = diagnosticSink;
     }
 
+    /// <summary>Serilog pipeline entry point.</summary>
     public void Emit(LogEvent logEvent)
     {
-        if (_disposed.IsFalse)
-            _ch.Writer.TryWrite(logEvent);
+        if (logEvent is null || _disposed.IsTrue)
+            return;
+
+        _ch.Writer.TryWrite(logEvent); // non-blocking; may drop when full
     }
 
-    private async Task ReadLoop()
+    public void Complete()
     {
-        await foreach (LogEvent evt in _ch.Reader.ReadAllAsync()
-                           .ConfigureAwait(false))
-        {
-            ITestOutputHelper? helper = _helper; // volatile read
+        if (_disposed.IsTrue)
+            return;
 
-            if (helper is null)
-            {
-                _pending.Enqueue(evt); // buffer until helper arrives
-                continue;
-            }
+        _helper = null; // stop xUnit writes
+        _ch.Writer.TryComplete(); // prefer graceful drain
+        // optional: don't cancel here; let Dispose handle fallback cancel on timeout
+    }
 
-            // first, flush any backlog that accumulated pre-inject
-            while (_pending.Count > 0)
+    private async Task ReadLoop(CancellationToken ct)
+    {
+        try
+        {
+            await foreach (LogEvent evt in _ch.Reader.ReadAllAsync(ct)
+                               .ConfigureAwait(false))
             {
-                Write(_pending.Dequeue(), helper);
+                if (ct.IsCancellationRequested) break;
+
+                ITestOutputHelper? helper = _helper; // volatile read
+                if (helper is null)
+                {
+                    if (_pending.Count < _backlogCap)
+                        _pending.Enqueue(evt);
+                    continue;
+                }
+
+                // Flush any backlog that accumulated before helper arrived
+                while (!ct.IsCancellationRequested && _pending.Count > 0)
+                    Write(_pending.Dequeue(), helper);
+
+                if (!ct.IsCancellationRequested)
+                    Write(evt, helper);
             }
-
-            Write(evt, helper);
+        }
+        catch (OperationCanceledException)
+        {
+            // expected during teardown
+        }
+        catch
+        {
+            // never let logging crash tests
         }
     }
 
     private void Write(LogEvent evt, ITestOutputHelper helper)
     {
-        _sw.Reset();
-        _fmt.Format(evt, _sw);
-        string message = _sw.Finish();
-
-        _sink?.OnMessage(new DiagnosticMessage(message));
-
         try
         {
-            helper.WriteLine(message);
+            _sw.Reset();
+            _fmt.Format(evt, _sw);
+            string message = _sw.Finish();
+
+            try
+            {
+                _sink?.OnMessage(new DiagnosticMessage(message));
+            }
+            catch
+            {
+                /* ignore */
+            }
+
+            try
+            {
+                helper.WriteLine(message);
+            }
+            catch (InvalidOperationException)
+            {
+                // test finished; helper invalid
+                _helper = null;
+
+                if (_pending.Count < _backlogCap)
+                    _pending.Enqueue(evt);
+            }
+            catch
+            {
+                _helper = null;
+            }
         }
-        catch (InvalidOperationException)
+        catch
         {
-            // Helper became invalid (test finished) – cache the event
-            _helper = null;
-            _pending.Enqueue(evt);
+            // swallow formatting/writing failures
         }
     }
 
     public async ValueTask DisposeAsync()
     {
-        if (!_disposed.TrySetTrue())
-            return;
+        if (!_disposed.TrySetTrue()) return;
 
-        // 1) Tell the reader no more items are coming
-        _ch.Writer.TryComplete();
+        _helper = null; // stop xUnit calls after this point
+        _ch.Writer.TryComplete(); // 1) tell reader: no more items
 
-        // 2) Let the reader finish formatting & flushing
-        await _readerTask.NoSync();
+        try
+        {
+            // 2) give the reader a short window to drain cleanly
+            await _readerTask.WaitAsync(_drainWait)
+                .NoSync();
+        }
+        catch (TimeoutException)
+        {
+            // 3) fallback: force-break the loop if it didn’t finish
+            await _cts.CancelAsync()
+                .NoSync();
+            try
+            {
+                await _readerTask.WaitAsync(_cancelWait)
+                    .NoSync();
+            }
+            catch
+            {
+                /* swallow during teardown */
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            /* ok */
+        }
 
-        await _sw.DisposeAsync()
-            .NoSync();
+        try
+        {
+            await _sw.DisposeAsync()
+                .NoSync();
+        }
+        catch
+        {
+        }
+
+        _cts.Dispose();
     }
 
     public void Dispose()
     {
-        if (!_disposed.TrySetTrue())
-            return;
+        if (!_disposed.TrySetTrue()) return;
 
+        _helper = null;
         _ch.Writer.TryComplete();
 
         try
@@ -129,9 +218,25 @@ public void Dispose()
         }
         catch
         {
-            // swallow during teardown
+            _cts.Cancel();
+            try
+            {
+                _readerTask.GetAwaiter()
+                    .GetResult();
+            }
+            catch
+            {
+            }
+        }
+
+        try
+        {
+            _sw.Dispose();
+        }
+        catch
+        {
         }
 
-        _sw.Dispose();
+        _cts.Dispose();
     }
 }

test/Sinks/BlockingCollectionInjectableTestOutputSink.cs

@@ -38,6 +38,11 @@ public BlockingCollectionInjectableTestOutputSink(string outputTemplate = _defau
     private static ReusableStringWriter RentWriter() =>
         _threadWriter ??= new ReusableStringWriter();
 
+    public void Complete()
+    {
+        throw new NotImplementedException();
+    }
+
     public void Inject(ITestOutputHelper helper, IMessageSink? sink = null)
     {
         ArgumentNullException.ThrowIfNull(helper);

test/Sinks/ChannelInjectableTestOutputSink.cs

@@ -43,6 +43,11 @@ public ChannelInjectableTestOutputSink(string outputTemplate = _defaultTemplate,
         _readerTask = Task.Run(ReadLoop);
     }
 
+    public void Complete()
+    {
+        throw new NotImplementedException();
+    }
+
     public void Inject(ITestOutputHelper helper, IMessageSink? sink = null)
     {
         ArgumentNullException.ThrowIfNull(helper);

test/Sinks/ConcurrentInjectableTestOutputSink.cs

@@ -31,6 +31,11 @@ public ConcurrentInjectableTestOutputSink(string outputTemplate = _defaultTempla
         _fmt = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
     }
 
+    public void Complete()
+    {
+        throw new NotImplementedException();
+    }
+
     public void Inject(ITestOutputHelper helper, IMessageSink? sink = null)
     {
         ArgumentNullException.ThrowIfNull(helper);

test/Sinks/OriginalInjectableTestOutputSink.cs

@@ -35,6 +35,11 @@ public OriginalInjectableTestOutputSink(string outputTemplate = _defaultConsoleO
         _textFormatter = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
     }
 
+    public void Complete()
+    {
+        throw new NotImplementedException();
+    }
+
     public void Inject(ITestOutputHelper testOutputHelper, IMessageSink? messageSink = null)
     {
         _testOutputHelper = testOutputHelper;

test/Sinks/QueueInjectableTestOutputSink.cs

@@ -31,6 +31,11 @@ public QueueInjectableTestOutputSink(string outputTemplate = _defaultTemplate, I
         _fmt = new MessageTemplateTextFormatter(outputTemplate, formatProvider);
     }
 
+    public void Complete()
+    {
+        throw new NotImplementedException();
+    }
+
     public void Inject(ITestOutputHelper helper, IMessageSink? sink = null)
     {
         ArgumentNullException.ThrowIfNull(helper);