Merge pull request #21 from Stravaig-Projects/#19/internal-replay-limit

(#19) Enforce replay log limit

Author: colinangusmackay

release-notes/wip-release-notes.md

@@ -4,6 +4,10 @@
 
 Date: ???
 
+### Features
+
+- #19: Limit the number of replayed logs.
+
 ### Miscellaneous
 
 - #18: Use compile time logging source generation.

src/Stravaig.Configuration.SqlServer.Tests/ReplayLoggerTests.cs

@@ -0,0 +1,61 @@
+using Microsoft.Extensions.Logging;
+using NUnit.Framework;
+using Shouldly;
+using Stravaig.Configuration.SqlServer.Glue;
+using Stravaig.Extensions.Logging.Diagnostics;
+using Stravaig.Extensions.Logging.Diagnostics.Render;
+
+namespace Stravaig.Configuration.SqlServer.Tests;
+
+[TestFixture]
+public class ReplayLoggerTests
+{
+    [Test]
+    public void LogsThatReplayLimitWasReached()
+    {
+        ReplayLogger replayLogger = new ();
+        for (int counter = 0; counter < 30; counter++)
+        {
+            replayLogger.LogInformation("This is log number {Counter}", counter);
+        }
+
+        TestCaptureLogger<ReplayLoggerTests> captureLogger = new ();
+        replayLogger.Replay(captureLogger);
+
+        var logs = captureLogger.GetLogs();
+        logs.RenderLogs(Formatter.SimpleBySequence, Sink.Console);
+        
+        logs.Count.ShouldBe(28);
+        
+        logs[0].OriginalMessage.ShouldBe("Replaying {Count} delayed logs. NOTE: Some replayed logs may not emit if filters prevent them.");
+        logs[0].PropertyDictionary["Count"].ShouldBe(25);
+        
+        logs[^2].OriginalMessage.ShouldBe("The replay limit was reached. There are {excessCount} logs that cannot be replayed.");
+        logs[^2].PropertyDictionary["excessCount"].ShouldBe(5);
+        
+        logs[^1].OriginalMessage.ShouldBe("End of replay.");
+    }
+    
+    [Test]
+    public void ReplayLogsHappyPath()
+    {
+        ReplayLogger replayLogger = new ();
+        for (int counter = 0; counter < 10; counter++)
+        {
+            replayLogger.LogInformation("This is log number {Counter}", counter);
+        }
+
+        TestCaptureLogger<ReplayLoggerTests> captureLogger = new ();
+        replayLogger.Replay(captureLogger);
+
+        var logs = captureLogger.GetLogs();
+        logs.RenderLogs(Formatter.SimpleBySequence, Sink.Console);
+        
+        logs.Count.ShouldBe(12);
+        
+        logs[0].OriginalMessage.ShouldBe("Replaying {Count} delayed logs. NOTE: Some replayed logs may not emit if filters prevent them.");
+        logs[0].PropertyDictionary["Count"].ShouldBe(10);
+        
+        logs[^1].OriginalMessage.ShouldBe("End of replay.");
+    }
+}

src/Stravaig.Configuration.SqlServer/Glue/Log.cs

@@ -52,4 +52,10 @@ public static partial class Log
         Level = LogLevel.Debug,
         Message = "Starting SQL Server Configuration DB Polling every {frequency} seconds.")]
     public static partial void StartingDbPolling(this ILogger logger, double frequency);
+
+    [LoggerMessage(
+        EventId = 9,
+        Level = LogLevel.Warning,
+        Message = "The replay limit was reached. There are {excessCount} logs that cannot be replayed.")]
+    public static partial void ReplayLimitExceeded(this ILogger logger, int excessCount);
 }

src/Stravaig.Configuration.SqlServer/Glue/ReplayLogger.cs

@@ -15,13 +15,12 @@ internal class ReplayLogger : ILogger
 
     private readonly object _lock = new ();
     private readonly Queue<Action<ILogger>> _logs;
-    private readonly Stack<IDisposable> _scopes;
     private readonly int _limit = 25;
+    private int _limitExcess;
 
-    public ReplayLogger()
+    internal ReplayLogger()
     {
-        this._logs = new Queue<Action<ILogger>>();
-        this._scopes = new Stack<IDisposable>();
+        _logs = new Queue<Action<ILogger>>();
     }
 
     public void Log<TState>(
@@ -39,7 +38,10 @@ void ReplayLog(ILogger logger)
         lock (_lock)
         {
             if (_logs.Count >= _limit)
-                _logs.Dequeue();
+            {
+                _limitExcess++;               
+                return;
+            }
             _logs.Enqueue(ReplayLog);
         }
     }
@@ -48,17 +50,7 @@ void ReplayLog(ILogger logger)
 
     public IDisposable BeginScope<TState>(TState state)
     {
-        lock (_lock)
-        {
-            _logs.Enqueue(logger =>
-            {
-                IDisposable scope = logger.BeginScope(state);
-
-                _scopes.Push(scope);
-            });
-
-            return new Scope(this);
-        }
+        return new Scope();
     }
 
     public void Replay(ILogger logger)
@@ -76,26 +68,19 @@ public void Replay(ILogger logger)
                 replayTo(logger);
             }
 
+            if (_limitExcess > 0)
+                logger.ReplayLimitExceeded(_limitExcess);
+                    
             _logs.Clear();
+            _limitExcess = 0;
         }
         logger.ReplayEnd();
     }
 
     private class Scope : IDisposable
     {
-        private readonly ReplayLogger _logger;
-
-        public Scope(ReplayLogger logger)
-        {
-            _logger = logger;
-        }
-
         public void Dispose()
         {
-            lock (_logger._lock)
-            {
-                _logger._logs.Enqueue(_ => this._logger._scopes.Pop());
-            }
         }
     }
 }

version.txt

@@ -1 +1 @@
-0.2.1
+0.3.0