Print All Loggers in Order of Last Written to

ModularPipelines/Engine/PipelineExecutor.cs

@@ -14,6 +14,7 @@ internal class PipelineExecutor : IPipelineExecutor
     private readonly EngineCancellationToken _engineCancellationToken;
     private readonly IDependencyDetector _dependencyDetector;
     private readonly IModuleResultPrinter _moduleResultPrinter;
+    private readonly IModuleLoggerContainer _moduleLoggerContainer;
 
     public PipelineExecutor(
         IPipelineSetupExecutor pipelineSetupExecutor,
@@ -23,7 +24,8 @@ public PipelineExecutor(
         IModuleExecutor moduleExecutor,
         EngineCancellationToken engineCancellationToken,
         IDependencyDetector dependencyDetector,
-        IModuleResultPrinter moduleResultPrinter)
+        IModuleResultPrinter moduleResultPrinter,
+        IModuleLoggerContainer moduleLoggerContainer)
     {
         _pipelineSetupExecutor = pipelineSetupExecutor;
         _pipelineConsolePrinter = pipelineConsolePrinter;
@@ -33,6 +35,7 @@ public PipelineExecutor(
         _engineCancellationToken = engineCancellationToken;
         _dependencyDetector = dependencyDetector;
         _moduleResultPrinter = moduleResultPrinter;
+        _moduleLoggerContainer = moduleLoggerContainer;
     }
 
     public async Task<IReadOnlyList<ModuleBase>> ExecuteAsync()
@@ -70,6 +73,8 @@ public async Task<IReadOnlyList<ModuleBase>> ExecuteAsync()
 
             await Task.Delay(200);
 
+            _moduleLoggerContainer.PrintAllLoggers();
+
             _moduleResultPrinter.PrintModuleResults();
         }
 

ModularPipelines/Host/PipelineHostBuilder.cs

@@ -56,6 +56,7 @@ internal PipelineHostBuilder()
                 .AddSingleton<IPipelineExecutor, PipelineExecutor>()
                 .AddSingleton<IModuleExecutor, ModuleExecutor>()
                 .AddSingleton(typeof(ModuleLogger<>))
+                .AddSingleton<IModuleLoggerContainer, ModuleLoggerContainer>()
                 .AddSingleton<IDependencyChainProvider, DependencyChainProvider>()
                 .AddSingleton<IDependencyDetector, DependencyDetector>()
                 .AddSingleton<IDependencyCollisionDetector, DependencyCollisionDetector>()

ModularPipelines/IModuleLoggerContainer.cs

@@ -0,0 +1,9 @@
+using Microsoft.Extensions.Logging;
+
+namespace ModularPipelines;
+
+internal interface IModuleLoggerContainer
+{
+    void PrintAllLoggers();
+    void AddLogger(ModuleLogger logger);
+}

ModularPipelines/ModuleLogger.cs

@@ -5,7 +5,16 @@
 
 namespace ModularPipelines;
 
-public class ModuleLogger<T> : ILogger<T>, IDisposable
+internal abstract class ModuleLogger : ILogger, IDisposable
+{
+    internal DateTime LastLogWritten { get; set; } = DateTime.MinValue;
+    public abstract void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter);
+    public abstract bool IsEnabled(LogLevel logLevel);
+    public abstract IDisposable BeginScope<TState>(TState state);
+    public abstract void Dispose();
+}
+
+internal class ModuleLogger<T> : ModuleLogger, ILogger<T>, IDisposable
 {
     private readonly IOptions<PipelineOptions> _options;
     private readonly ILogger<T> _defaultLogger;
@@ -15,23 +24,24 @@ public class ModuleLogger<T> : ILogger<T>, IDisposable
     private bool _isDisposed;
 
     // ReSharper disable once ContextualLoggerProblem
-    public ModuleLogger(IOptions<PipelineOptions> options, ILogger<T> defaultLogger)
+    public ModuleLogger(IOptions<PipelineOptions> options, ILogger<T> defaultLogger, IModuleLoggerContainer moduleLoggerContainer)
     {
         _options = options;
         _defaultLogger = defaultLogger;
+        moduleLoggerContainer.AddLogger(this);
     }
 
-    public IDisposable BeginScope<TState>(TState state)
+    public override IDisposable BeginScope<TState>(TState state)
     {
         return new NoopDisposable();
     }
 
-    public bool IsEnabled(LogLevel logLevel)
+    public override bool IsEnabled(LogLevel logLevel)
     {
         return logLevel >= _options.Value.LoggerOptions.LogLevel;
     }
 
-    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter)
+    public override void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter)
     {
         if (!IsEnabled(logLevel) || _isDisposed)
         {
@@ -43,6 +53,8 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
         var valueTuple = (logLevel, eventId, state, exception, mappedFormatter);
 
         _logEvents.Add(valueTuple!);
+
+        LastLogWritten = DateTime.UtcNow;
     }
 
     private Func<object, Exception?, string> MapFormatter<TState>(Func<TState,Exception?,string>? formatter)
@@ -63,8 +75,13 @@ public void Dispose()
     }
 
     [MethodImpl(MethodImplOptions.Synchronized)]
-    public void Dispose()
+    public override void Dispose()
     {
+        if (_isDisposed)
+        {
+            return;
+        }
+
         _isDisposed = true;
 
         var logEvents = Interlocked.Exchange(ref _logEvents!, new List<(LogLevel logLevel, EventId eventId, object state, Exception exception, Func<object, Exception?, string> formatter)>());

ModularPipelines/ModuleLoggerContainer.cs

@@ -0,0 +1,21 @@
+using Microsoft.Extensions.Logging;
+
+namespace ModularPipelines;
+
+internal class ModuleLoggerContainer : IModuleLoggerContainer
+{
+    private readonly List<ModuleLogger> _loggers = new();
+
+    public void PrintAllLoggers()
+    {
+        foreach (var logger in _loggers.OrderBy(x => x.LastLogWritten))
+        {
+            logger.Dispose();
+        }
+    }
+
+    public void AddLogger(ModuleLogger logger)
+    {
+        _loggers.Add(logger);
+    }
+}