feat: add progress and status handling with cancellation support and new payloads

Author: WolfBublitz

src/Extensions/ILoggerExtensions.cs

@@ -74,6 +74,32 @@ public static ILogger HorizontalRule(this ILogger @this, string? title = null)
         return @this;
     }
 
+    public static async Task ProgressAsync(this ILogger @this, Func<Progress, Task> action, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(@this);
+        ArgumentNullException.ThrowIfNull(action);
+
+        ProgressStartPayload startPayload = new()
+        {
+            CancellationToken = cancellationToken,
+        };
+
+        @this.Log(null, startPayload);
+
+        Progress progress = await startPayload.WaitForProgressAsync().ConfigureAwait(false);
+
+        await action(progress).ConfigureAwait(false);
+
+        ProgressFinishedPayload finishedPayload = new()
+        {
+            CancellationToken = cancellationToken,
+        };
+
+        @this.Log(null, finishedPayload);
+
+        await finishedPayload.WaitForFinishedAsync().ConfigureAwait(false);
+    }
+
     /// <summary>
     /// Starts a progress with the <paramref name="progressConfiguration"/> running the specified <paramref name="action"/> function. 
     /// The progress will be automatically completed when the <paramref name="action"/> function completes.
@@ -112,7 +138,7 @@ public static async Task StartProgressAsync(this ILogger @this, Action<Progress>
     public static async Task StartProgressAsync(this ILogger @this, Func<ProgressContext, CancellationToken, Task> action, CancellationToken cancellationToken = default)
         => await StartProgressAsync(@this, _ => { }, action, cancellationToken).ConfigureAwait(false);
 
-    public static async Task StartStatusAsync(this ILogger @this, string message, Action<Status> status, Func<StatusContext, Task> action)
+    public static async Task StartStatusAsync(this ILogger @this, string message, Action<Status> status, Func<StatusContext, CancellationToken, Task> action, CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(@this);
 
@@ -121,15 +147,16 @@ public static async Task StartStatusAsync(this ILogger @this, string message, Ac
             StatusConfigurationAction = status,
             StatusAction = action,
             StatusMessage = message,
+            CancellationToken = cancellationToken,
         };
 
-        await @this.FlushAsync().ConfigureAwait(false);
+        await @this.FlushAsync(cancellationToken).ConfigureAwait(false);
 
         @this.Log(null, statusPayload);
 
         await statusPayload.Completed.ConfigureAwait(false);
     }
 
     public static Task StartStatusAsync(this ILogger @this, string statusMessage, Func<StatusContext, Task> action)
-        => StartStatusAsync(@this, statusMessage, _ => { }, action);
+        => StartStatusAsync(@this, statusMessage, _ => { }, (context, cancellationToken) => action(context), CancellationToken.None);
 }

src/Extensions/TaskExtensions.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Spectre.Console;
+
+namespace WB.Logging.LogSinks.Console.Spectre;
+
+internal static class TaskExtensions
+{
+    internal static async Task StartAsync(this Task<Progress> @this, Func<ProgressContext, CancellationToken, Task> action, CancellationToken cancellationToken = default)
+    {
+        Progress progress = await @this.ConfigureAwait(false);
+
+        await progress.StartAsync(context => action(context, cancellationToken)).ConfigureAwait(false);
+    }
+}

src/LogMessageWriters/ProgressConsoleMessageWriter.cs

@@ -10,8 +10,12 @@ namespace WB.Logging.LogSinks.Console.Spectre;
 /// A log message writer that uses Spectre.Console's progress bar to 
 /// render progress updates in the console.
 /// </summary>
-internal sealed class ProgressConsoleMessageWriter : IAsyncLogMessageWriter<ProgressPayload, IAnsiConsole>
+internal sealed class ProgressConsoleMessageWriter
+    : IAsyncLogMessageWriter<ProgressStartPayload, IAnsiConsole>
+    , IAsyncLogMessageWriter<ProgressFinishedPayload, IAnsiConsole>
 {
+    private IDisposable? logSinkDisabledSubscription;
+
     // ┌─────────────────────────────────────────────────────────────────────────────┐
     // │ Public Properties                                                           │
     // └─────────────────────────────────────────────────────────────────────────────┘
@@ -26,26 +30,29 @@ internal sealed class ProgressConsoleMessageWriter : IAsyncLogMessageWriter<Prog
     // │ Public Methods                                                              │
     // └─────────────────────────────────────────────────────────────────────────────┘
 
-    /// <inheritdoc/>
-    public async ValueTask WriteAsync(DateTimeOffset timestamp, LogLevel? logLevel, IEnumerable<string> senders, ProgressPayload payload)
+    public ValueTask WriteAsync(DateTimeOffset timestamp, LogLevel? logLevel, IEnumerable<string> senders, ProgressStartPayload payload)
     {
-#pragma warning disable CA1031 // Do not catch general exception types
-        try
+        if (logSinkDisabledSubscription is null)
         {
-            using IDisposable _ = payload.CancellationToken.Register(payload.SetCanceled);
-
-            Progress progress = Writer.Progress();
+            logSinkDisabledSubscription = LogSink?.Disable();
 
-            payload.ProgressConfigurationAction(progress);
+            payload.SetProgress(Writer.Progress());
+        }
 
-            await progress.StartAsync(context => payload.ProgressAction(context, payload.CancellationToken)).ConfigureAwait(false);
+        return ValueTask.CompletedTask;
+    }
 
-            payload.SetCompleted();
-        }
-        catch (Exception exception)
+    public ValueTask WriteAsync(DateTimeOffset timestamp, LogLevel? logLevel, IEnumerable<string> senders, ProgressFinishedPayload payload)
+    {
+        if (logSinkDisabledSubscription is not null)
         {
-            payload.SetException(exception);
+            logSinkDisabledSubscription.Dispose();
+            logSinkDisabledSubscription = null;
+
+            payload.SetFinished();
         }
-#pragma warning restore CA1031 // Do not catch general exception types
+
+        return ValueTask.CompletedTask;
     }
+
 }

src/LogMessageWriters/StatusConsoleMessageWriter.cs

@@ -36,7 +36,7 @@ public async ValueTask WriteAsync(DateTimeOffset timestamp, LogLevel? logLevel,
 
             payload.StatusConfigurationAction(status);
 
-            await status.StartAsync(payload.StatusMessage, payload.StatusAction).ConfigureAwait(false);
+            await status.StartAsync(payload.StatusMessage, context => payload.StatusAction(context, payload.CancellationToken)).ConfigureAwait(false);
 
             payload.SetCompleted();
         }

src/Payloads/ProgressFinishedPayload.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Spectre.Console;
+
+namespace WB.Logging.LogSinks.Console.Spectre;
+
+internal sealed class ProgressFinishedPayload
+{
+    private readonly TaskCompletionSource taskCompletionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+    public CancellationToken CancellationToken { get; init; } = CancellationToken.None;
+
+    public void SetFinished()
+        => taskCompletionSource.TrySetResult();
+
+    public Task WaitForFinishedAsync()
+        => taskCompletionSource.Task;
+}

src/Payloads/ProgressStartPayload.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Spectre.Console;
+
+namespace WB.Logging.LogSinks.Console.Spectre;
+
+internal sealed class ProgressStartPayload
+{
+    private readonly TaskCompletionSource<Progress> taskCompletionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
+
+    public CancellationToken CancellationToken { get; init; } = CancellationToken.None;
+
+    public void SetProgress(Progress progress)
+        => taskCompletionSource.TrySetResult(progress);
+
+    public Task<Progress> WaitForProgressAsync()
+        => taskCompletionSource.Task;
+}

src/Payloads/StatusPayload.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Spectre.Console;
 
@@ -24,10 +25,12 @@ internal sealed class StatusPayload
     /// <summary>
     /// Gets or sets the action that performs the status update.
     /// </summary>
-    public required Func<StatusContext, Task> StatusAction { get; init; }
+    public required Func<StatusContext, CancellationToken, Task> StatusAction { get; init; }
 
     public Action<Status> StatusConfigurationAction { get; init; } = _ => { };
 
+    public CancellationToken CancellationToken { get; init; } = CancellationToken.None;
+
     /// <summary>
     /// Gets a <see cref="Task"/> that represents the completion of the status. The 
     /// <see cref="Task"/> will complete when the status is completed or if an exception 

src/SpectreConsoleLogSink.cs

@@ -10,6 +10,8 @@ namespace WB.Logging.LogSinks.Console.Spectre;
 /// </summary>
 public sealed class SpectreConsoleLogSink : AsyncLogSinkBase<IAnsiConsole>
 {
+    private readonly ProgressConsoleMessageWriter progressConsoleMessageWriter = new();
+
     // ┌─────────────────────────────────────────────────────────────────────────────┐
     // │ Public Constructors                                                         │
     // └─────────────────────────────────────────────────────────────────────────────┘
@@ -20,6 +22,7 @@ public sealed class SpectreConsoleLogSink : AsyncLogSinkBase<IAnsiConsole>
     public SpectreConsoleLogSink() : base(new SpectreConsoleLogMessageWriter<object>(), AnsiConsole.Console)
     {
         RegisterLogMessageWriter(new PayloadLogMessageWriter());
-        RegisterLogMessageWriter(new ProgressConsoleMessageWriter());
+        RegisterLogMessageWriter<ProgressStartPayload>(progressConsoleMessageWriter);
+        RegisterLogMessageWriter<ProgressFinishedPayload>(progressConsoleMessageWriter);
     }
 }

tests/ExtensionsTests/src/ILoggerExtensionsTests/ProgressAsyncMethodTests.cs

@@ -0,0 +1,42 @@
+using System.Threading.Tasks;
+using AwesomeAssertions;
+using Spectre.Console;
+using Spectre.Console.Testing;
+using WB.Logging;
+using WB.Logging.LogSinks.Console.Spectre;
+
+namespace ExtensionsTests.ILoggerExtensionsTests.ProgressAsyncMethodTests;
+
+public sealed class TheProgressAsyncMethod
+{
+    [Test]
+    public async Task ShouldRunAProgress()
+    {
+        // Arrange
+        TestConsole testConsole = new();
+        ILogger logger = new Logger("test");
+        logger.AttachSpectreConsole(logSink =>
+        {
+            logSink.Writer = testConsole;
+        });
+
+        // Act
+        await logger.ProgressAsync(async progress =>
+        {
+            await progress.StartAsync(async context =>
+            {
+                ProgressTask task = context.AddTask("Processing...").MaxValue(100);
+
+                for (int i = 0; i < 100; i++)
+                {
+                    task.Increment(1);
+                    await Task.Delay(10);
+                }
+            }).ConfigureAwait(false);
+        });
+        await logger.FlushAsync();
+
+        // Assert
+        testConsole.Output.Should().Contain("Processing...");
+    }
+}