move to source generated logger

src/Blumchen/DependencyInjection/LoggerExtensions.cs

@@ -0,0 +1,18 @@
+using Blumchen.Subscriptions.Replication;
+using Microsoft.Extensions.Logging;
+
+namespace Blumchen.DependencyInjection;
+
+internal static partial class LoggerExtensions
+
+{
+    [LoggerMessage(Message = "{workerName} started", Level = LogLevel.Information)]
+    public static partial void ServiceStarted(this ILogger logger, string workerName);
+
+    [LoggerMessage(Message = "{workerName} sopped", Level = LogLevel.Information)]
+    public static partial void ServiceStopped(this ILogger logger, string workerName);
+
+    [LoggerMessage(Message = "{message} processed", Level = LogLevel.Trace)]
+    public static partial void MessageProcessed(this ILogger logger, IEnvelope message);
+
+}

src/Blumchen/DependencyInjection/Worker.cs

@@ -1,4 +1,3 @@
-using System.Collections.Concurrent;
 using Blumchen.Subscriptions;
 using Blumchen.Subscriptions.Replication;
 using Microsoft.Extensions.Hosting;
@@ -11,25 +10,6 @@ public class Worker<T>(
     ILogger<Worker<T>> logger): BackgroundService where T : class, IMessageHandler
 {
     private string WorkerName { get; } = $"{nameof(Worker<T>)}<{typeof(T).Name}>";
-    private static readonly ConcurrentDictionary<string, Action<ILogger, string, object[]>> LoggingActions = new(StringComparer.OrdinalIgnoreCase);
-    private static void Notify(ILogger logger, LogLevel level, string template, params object[] parameters)
-    {
-        LoggingActions.GetOrAdd(template,_ => LoggerAction(level, logger.IsEnabled(level)))(logger, template, parameters);
-        return;
-
-        static Action<ILogger, string, object[]> LoggerAction(LogLevel ll, bool enabled) =>
-            (ll, enabled) switch
-            {
-                (LogLevel.Information, true) => (logger, template, parameters) => logger.LogInformation(template, parameters),
-                (LogLevel.Debug, true) => (logger, template, parameters) => logger.LogDebug(template, parameters),
-                (LogLevel.Trace, true) => (logger, template, parameters) => logger.LogTrace(template, parameters),
-                (LogLevel.Warning, true) => (logger, template, parameters) => logger.LogWarning(template, parameters),
-                (LogLevel.Error, true) => (logger, template, parameters) => logger.LogError(template, parameters),
-                (LogLevel.Critical, true) => (logger, template, parameters) => logger.LogCritical(template, parameters),
-                (_, _) => (_, _, _) => { }
-            };
-    }
-
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
         await options.OuterPipeline.ExecuteAsync(async token =>
@@ -38,11 +18,11 @@ await options.InnerPipeline.ExecuteAsync(async ct =>
             await using var subscription = new Subscription();
             await using var cursor = subscription.Subscribe(options.SubscriberOptions, ct)
                 .GetAsyncEnumerator(ct);
-            Notify(logger, LogLevel.Information, "{WorkerName} started", WorkerName);
+            logger.ServiceStarted(WorkerName);
             while (await cursor.MoveNextAsync().ConfigureAwait(false) && !ct.IsCancellationRequested)
-                Notify(logger, LogLevel.Trace, "{cursor.Current} processed", cursor.Current);
+               logger.MessageProcessed(cursor.Current);
         }, token).ConfigureAwait(false), stoppingToken).ConfigureAwait(false);
-        Notify(logger, LogLevel.Information, "{WorkerName} stopped", WorkerName);
+        logger.ServiceStopped(WorkerName);
     }
 
 }