Add LogManager.Flush as a public API

A similar feature was already present internally, this is an improved version which can be useful for external benchmarks.

src/ZeroLog.Benchmarks/LatencyTests/LatencyBenchmarks.cs

@@ -72,7 +72,7 @@ public void ZeroLog()
 
     [IterationCleanup(Target = nameof(ZeroLog))]
     public void CleanupZeroLogIteration()
-        => LogManager.WaitUntilQueueIsEmpty();
+        => LogManager.Flush();
 
     //
     // Serilog

src/ZeroLog.Impl.Full/LogManager.Impl.cs

@@ -98,6 +98,22 @@ public static IDisposable Initialize(ZeroLogConfiguration configuration)
     public static void Shutdown()
         => _staticLogManager?.Dispose();
 
+    /// <summary>
+    /// Waits until all the messages logged so far have been processed by the appenders.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This is mostly meant for benchmarking, to ensure all the enqueued data has been processed.
+    /// </para>
+    /// <para>
+    /// It could also be used for unit testing, but in that case it is recommended to set
+    /// the <see cref="ZeroLogConfiguration.AppendingStrategy"/> property in the configuration
+    /// to <see cref="AppendingStrategy.Synchronous"/> instead, which removes all threading-related issues.
+    /// </para>
+    /// </remarks>
+    public static void Flush()
+        => _staticLogManager?._runner?.Flush();
+
     /// <summary>
     /// Registers an enum type.
     /// Member names will be used when formatting the message (instead of numeric values).
@@ -202,7 +218,4 @@ private void UpdateAllLogConfigurations()
 
     internal void WaitUntilNewConfigurationIsApplied() // For unit tests
         => _runner?.WaitUntilNewConfigurationIsApplied();
-
-    internal static void WaitUntilQueueIsEmpty() // For benchmarks
-        => (_staticLogManager?._runner as AsyncRunner)?.WaitUntilQueueIsEmpty();
 }

src/ZeroLog.Impl.Full/Runner.cs

@@ -51,7 +51,10 @@ public void Dispose()
         _appenders = [];
 
         foreach (var appender in appenders)
+        {
+            appender.InternalFlush();
             appender.Dispose();
+        }
     }
 
     public LogMessage AcquireLogMessage(LogMessagePoolExhaustionStrategy poolExhaustionStrategy)
@@ -116,6 +119,7 @@ public LogMessage AcquireLogMessage(LogMessagePoolExhaustionStrategy poolExhaust
     public abstract void Submit(LogMessage message);
 
     public abstract void UpdateConfiguration(ZeroLogConfiguration newConfig);
+    public abstract void Flush();
     protected abstract void Stop();
 
     internal virtual void WaitUntilNewConfigurationIsApplied() // For unit tests
@@ -173,6 +177,8 @@ protected void ApplyConfigurationUpdate(ZeroLogConfiguration newConfig)
 
 internal sealed class AsyncRunner : Runner
 {
+    private static readonly LogMessage _flushMessage = new(string.Empty);
+
     private readonly ConcurrentQueue<LogMessage> _queue;
     private readonly Thread _thread;
 
@@ -270,7 +276,11 @@ private bool TryToProcessQueue()
         if (!_queue.TryDequeue(out var logMessage))
             return false;
 
-        ProcessMessage(logMessage);
+        if (ReferenceEquals(logMessage, _flushMessage))
+            FlushAppenders();
+        else
+            ProcessMessage(logMessage);
+
         return true;
     }
 
@@ -285,9 +295,13 @@ private bool TryApplyConfigurationUpdate()
         return true;
     }
 
-    public void WaitUntilQueueIsEmpty()
+    public override void Flush()
     {
+        if (!IsRunning)
+            return;
+
         var spinWait = new SpinWait();
+        _queue.Enqueue(_flushMessage);
 
         while (!_queue.IsEmpty)
             spinWait.SpinOnce();
@@ -315,6 +329,16 @@ public override void UpdateConfiguration(ZeroLogConfiguration newConfig)
         }
     }
 
+    public override void Flush()
+    {
+        lock (_lock)
+        {
+            // An explicit flush should be a no-op with this runner,
+            // but the lock can cause an observable delay, so do it anyway.
+            FlushAppenders();
+        }
+    }
+
     protected override void Stop()
     {
     }

src/ZeroLog.Tests/AllocationTests.cs

@@ -80,7 +80,7 @@ public void should_not_allocate_using_all_formats_and_file_appender_builder()
         {
             if (i == warmupEvents)
             {
-                LogManager.WaitUntilQueueIsEmpty();
+                LogManager.Flush();
 
                 allocationsOnLoggingThread = GC.GetAllocatedBytesForCurrentThread();
                 allocationsOnAppenderThread = _awaitableAppender.AllocatedBytesOnAppenderThread;
@@ -156,7 +156,7 @@ public void should_not_allocate_using_all_formats_and_file_appender_builder()
         }
 
         // Give the appender some time to finish writing to file
-        LogManager.WaitUntilQueueIsEmpty();
+        LogManager.Flush();
 
         allocationsOnLoggingThread = GC.GetAllocatedBytesForCurrentThread() - allocationsOnLoggingThread;
         allocationsOnAppenderThread = _awaitableAppender.AllocatedBytesOnAppenderThread - allocationsOnAppenderThread;

src/ZeroLog.Tests/LogManagerTests.cs

@@ -74,6 +74,16 @@ public void should_log_all_remaining_messages_on_shutdown()
         _testAppender.LoggedMessages.ShouldHaveSingleItem().ShouldEqual("test");
     }
 
+    [Test]
+    public void should_flush()
+    {
+        var log = LogManager.GetLogger<LogManagerTests>();
+        log.Info("test");
+        LogManager.Flush();
+
+        _testAppender.LoggedMessages.ShouldHaveSingleItem().ShouldEqual("test");
+    }
+
     [Test]
     public void should_prevent_initializing_already_initialized_log_manager()
     {

src/ZeroLog.Tests/RunnerTests.Async.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading;
+using System.Threading.Tasks;
 using NUnit.Framework;
 using ZeroLog.Configuration;
 using ZeroLog.Tests.Support;
@@ -61,6 +62,24 @@ public void should_flush_appenders_when_not_logging_messages()
         Wait.Until(() => _testAppender.FlushCount == 2, TimeSpan.FromSeconds(1));
     }
 
+    [Test]
+    public void should_flush_appenders_explicitly()
+    {
+        _testAppender.WaitOnWriteEvent = new ManualResetEventSlim(false);
+
+        _log.Info("Foo");
+        _log.Info("Bar");
+        _log.Info("Baz");
+
+        var flushTask = Task.Factory.StartNew(() => _runner.Flush(), TaskCreationOptions.LongRunning);
+        flushTask.Wait(TimeSpan.FromSeconds(1)).ShouldBeFalse();
+
+        _testAppender.WaitOnWriteEvent.Set();
+
+        flushTask.Wait(TimeSpan.FromSeconds(1)).ShouldBeTrue();
+        _testAppender.FlushCount.ShouldEqual(1);
+    }
+
     [Test]
     public void should_apply_configuration_updates()
     {
@@ -91,7 +110,7 @@ public void should_not_log_pool_exhaustion_message_twice_in_a_row()
         _runner.AcquireLogMessage(LogMessagePoolExhaustionStrategy.DropLogMessageAndNotifyAppenders).ShouldBeTheSameAs(LogMessage.Empty);
 
         _runner.Submit(firstMessage);
-        _runner.WaitUntilQueueIsEmpty();
+        _runner.Flush();
         Thread.Sleep(500);
 
         _runner.AcquireLogMessage(LogMessagePoolExhaustionStrategy.DropLogMessageAndNotifyAppenders).ConstantMessage.ShouldBeNull();

src/ZeroLog.Tests/SanityChecks.should_have_expected_public_api.DotNet6_0.verified.txt

@@ -804,6 +804,7 @@ namespace ZeroLog
     {
         public static ZeroLog.Configuration.ZeroLogConfiguration? Configuration { get; }
         public void Dispose() { }
+        public static void Flush() { }
         public static ZeroLog.Log GetLogger(string name) { }
         public static ZeroLog.Log GetLogger(System.Type type) { }
         public static ZeroLog.Log GetLogger<T>() { }

src/ZeroLog.Tests/SanityChecks.should_have_expected_public_api.DotNet7_0.verified.txt

@@ -804,6 +804,7 @@ namespace ZeroLog
     {
         public static ZeroLog.Configuration.ZeroLogConfiguration? Configuration { get; }
         public void Dispose() { }
+        public static void Flush() { }
         public static ZeroLog.Log GetLogger(string name) { }
         public static ZeroLog.Log GetLogger(System.Type type) { }
         public static ZeroLog.Log GetLogger<T>() { }

src/ZeroLog.Tests/SanityChecks.should_have_expected_public_api.DotNet8_0.verified.txt

@@ -804,6 +804,7 @@ namespace ZeroLog
     {
         public static ZeroLog.Configuration.ZeroLogConfiguration? Configuration { get; }
         public void Dispose() { }
+        public static void Flush() { }
         public static ZeroLog.Log GetLogger(string name) { }
         public static ZeroLog.Log GetLogger(System.Type type) { }
         public static ZeroLog.Log GetLogger<T>() { }