+semver:minor - context.LogOnPipelineEnd(...) method (#497)

* `context.LogOnPipelineEnd(...)` method to easily log information at the end of the pipeline where it's easier to find in logs

* Formatting Markdown

* Tests

* catch

* Move call to AfterPipelineLogger

---------

Co-authored-by: Tom Longhurst <[email protected]>

Author: thomhurst

src/ModularPipelines.Build/Modules/NugetVersionGeneratorModule.cs

@@ -2,6 +2,7 @@
 using Microsoft.Extensions.Options;
 using ModularPipelines.Build.Settings;
 using ModularPipelines.Context;
+using ModularPipelines.Extensions;
 using ModularPipelines.Git.Extensions;
 using ModularPipelines.Modules;
 
@@ -21,12 +22,13 @@ public NugetVersionGeneratorModule(IOptions<PublishSettings> publishSettings)
     {
         var gitVersionInformation = await context.Git().Versioning.GetGitVersioningInformation();
 
-        if (_publishSettings.Value.IsAlpha)
-        {
-            return $"{gitVersionInformation.FullSemVer}-alpha{gitVersionInformation.CommitsSinceVersionSourcePadded!}";
-        }
+        var version = _publishSettings.Value.IsAlpha 
+            ? $"{gitVersionInformation.FullSemVer}-alpha{gitVersionInformation.CommitsSinceVersionSourcePadded!}" 
+            : gitVersionInformation.FullSemVer!;
 
-        return gitVersionInformation.FullSemVer;
+        context.LogOnPipelineEnd($"Generated Version Number: {version}");
+
+        return version;
     }
 
     /// <inheritdoc/>

src/ModularPipelines.Build/ReleaseNotes.md

@@ -1 +1,2 @@
 *   Throw an exception when defining duplicate constraint keys on the same NotInParallel attribute
+*   `context.LogOnPipelineEnd(...)` method to easily log information at the end of the pipeline where it's easier to find in logs

src/ModularPipelines/DependencyInjection/DependencyInjectionSetup.cs

@@ -67,6 +67,7 @@ public static void Initialize(IServiceCollection services)
         // Singletons
         services
             .AddSingleton<IConsolePrinter, ConsolePrinter>()
+            .AddSingleton<IAfterPipelineLogger, AfterPipelineLogger>()
             .AddSingleton<IExceptionContainer, ExceptionContainer>()
             .AddSingleton<IPipelineContextProvider, ModuleContextProvider>()
             .AddSingleton<IDependencyChainProvider, DependencyChainProvider>()

src/ModularPipelines/Engine/Executors/ExecutionOrchestrator.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics;
 using Microsoft.Extensions.Logging;
 using ModularPipelines.Helpers;
+using ModularPipelines.Logging;
 using ModularPipelines.Models;
 using ModularPipelines.Modules;
 
@@ -14,6 +15,7 @@ internal class ExecutionOrchestrator : IExecutionOrchestrator
     private readonly IPrintProgressExecutor _printProgressExecutor;
     private readonly IPipelineExecutor _pipelineExecutor;
     private readonly IConsolePrinter _consolePrinter;
+    private readonly IAfterPipelineLogger _afterPipelineLogger;
     private readonly EngineCancellationToken _engineCancellationToken;
     private readonly ILogger<ExecutionOrchestrator> _logger;
 
@@ -27,6 +29,7 @@ public ExecutionOrchestrator(IPipelineInitializer pipelineInitializer,
         IPrintProgressExecutor printProgressExecutor,
         IPipelineExecutor pipelineExecutor,
         IConsolePrinter consolePrinter,
+        IAfterPipelineLogger afterPipelineLogger,
         EngineCancellationToken engineCancellationToken,
         ILogger<ExecutionOrchestrator> logger)
     {
@@ -36,6 +39,7 @@ public ExecutionOrchestrator(IPipelineInitializer pipelineInitializer,
         _printProgressExecutor = printProgressExecutor;
         _pipelineExecutor = pipelineExecutor;
         _consolePrinter = consolePrinter;
+        _afterPipelineLogger = afterPipelineLogger;
         _engineCancellationToken = engineCancellationToken;
         _logger = logger;
     }
@@ -48,9 +52,13 @@ public async Task<PipelineSummary> ExecuteAsync(CancellationToken cancellationTo
         }
         catch
         {
-            await Task.Delay(TimeSpan.FromSeconds(1));
+            await Task.Delay(TimeSpan.FromSeconds(1), CancellationToken.None);
             throw;
         }
+        finally
+        {
+            _afterPipelineLogger.WriteLogs();
+        }
     }
 
     private async Task<PipelineSummary> ExecuteInternal(CancellationToken cancellationToken)

src/ModularPipelines/Engine/Executors/PipelineExecutor.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using Microsoft.Extensions.Logging;
+using ModularPipelines.Logging;
 using ModularPipelines.Models;
 using ModularPipelines.Modules;
 

src/ModularPipelines/Extensions/ContextExtensions.cs

@@ -0,0 +1,13 @@
+using ModularPipelines.Context;
+using ModularPipelines.Logging;
+
+namespace ModularPipelines.Extensions;
+
+public static class ContextExtensions
+{
+    public static void LogOnPipelineEnd(this IPipelineHookContext pipelineContext, string value)
+    {
+        var afterPipelineLogger = pipelineContext.Get<IAfterPipelineLogger>()!;
+        afterPipelineLogger.LogOnPipelineEnd(value);
+    }
+}

src/ModularPipelines/Logging/AfterPipelineLogger.cs

@@ -0,0 +1,27 @@
+using Microsoft.Extensions.Logging;
+
+namespace ModularPipelines.Logging;
+
+internal class AfterPipelineLogger : IAfterPipelineLogger
+{
+    private readonly ILogger<AfterPipelineLogger> _logger;
+    private readonly List<string> _values = [];
+
+    public AfterPipelineLogger(ILogger<AfterPipelineLogger> logger)
+    {
+        _logger = logger;
+    }
+    
+    public void LogOnPipelineEnd(string value)
+    {
+        _values.Add(value);
+    }
+
+    public void WriteLogs()
+    {
+        foreach (var value in _values)
+        {
+            _logger.LogInformation("{Value}", value);
+        }
+    }
+}

src/ModularPipelines/Logging/IAfterPipelineLogger.cs

@@ -0,0 +1,8 @@
+namespace ModularPipelines.Logging;
+
+public interface IAfterPipelineLogger
+{
+    void LogOnPipelineEnd(string value);
+    
+    internal void WriteLogs();
+}

test/ModularPipelines.UnitTests/AfterPipelineLoggerTests.cs

@@ -0,0 +1,83 @@
+using System.Text;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using ModularPipelines.Context;
+using ModularPipelines.Extensions;
+using ModularPipelines.Modules;
+using ModularPipelines.TestHelpers;
+using NReco.Logging.File;
+using TUnit.Assertions.Extensions;
+using File = ModularPipelines.FileSystem.File;
+using Type = System.Type;
+
+namespace ModularPipelines.UnitTests;
+
+public class AfterPipelineLoggerTests
+{
+    private class AfterPipelineLoggingModule : Module
+    {
+        protected override async Task<IDictionary<string, object>?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+        {
+            context.LogOnPipelineEnd("Blah!");
+            await Task.CompletedTask;
+            return null;
+        }
+    }
+    
+    private class AfterPipelineLoggingWithExceptionModule : Module
+    {
+        protected override async Task<IDictionary<string, object>?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+        {
+            context.LogOnPipelineEnd("Blah!");
+            await Task.CompletedTask;
+            throw new Exception();
+        }
+    }
+    
+    [Test]
+    public async Task LogsAfterPipeline()
+    {
+        var stringBuilder = new StringBuilder();
+        var host = await TestPipelineHostBuilder.Create()
+            .ConfigureServices((_, collection) =>
+            {
+                collection.AddSingleton(stringBuilder);
+                collection.AddSingleton(typeof(ILogger<>), typeof(StringLogger<>));
+            })
+            .AddModule<AfterPipelineLoggingModule>()
+            .BuildHostAsync();
+
+        await host.ExecutePipelineAsync();
+
+        await host.DisposeAsync();
+        
+        await Assert.That(stringBuilder.ToString().Trim()).Does.EndWith("Blah!");
+    }
+    
+    [Test]
+    public async Task LogsAfterPipelineWithException()
+    {
+        var stringBuilder = new StringBuilder();
+        var host = await TestPipelineHostBuilder.Create()
+            .ConfigureServices((_, collection) =>
+            {
+                collection.AddSingleton(stringBuilder);
+                collection.AddSingleton(typeof(ILogger<>), typeof(StringLogger<>));
+            })
+            .AddModule<AfterPipelineLoggingWithExceptionModule>()
+            .BuildHostAsync();
+
+        try
+        {
+            await host.ExecutePipelineAsync();
+        }
+        catch
+        {
+            // Ignored
+        }
+
+        await host.DisposeAsync();
+        
+        await Assert.That(stringBuilder.ToString().Trim()).Does.EndWith("Blah!");
+    }
+}