Fixed multi logger issue

Author: dei79

dotNet/CoreHelpers.Extensions.Logging.Tasks/TaskLoggerExtension.cs

@@ -16,6 +16,6 @@ public static ILoggingBuilder AddTaskLogger(this ILoggingBuilder builder)
             => logger.BeginScope<TaskLoggerState>(new TaskLoggerState() { TaskId = taskId, IsTaskAnnounced = true });
 
         public static IDisposable? BeginNewTaskScope(this ILogger logger, string taskType, string taskSource, string taskWorker)
-            => logger.BeginScope<TaskLoggerState>(new TaskLoggerState() { TaskId = string.Empty, TaskType = taskType, TaskSource = taskSource, TaskWorker = taskSource, IsTaskAnnounced = false });
+            => logger.BeginScope<TaskLoggerState>(new TaskLoggerState() { TaskId = string.Empty, TaskType = taskType, TaskSource = taskSource, TaskWorker = taskWorker, IsTaskAnnounced = false });
     }
 }

dotNet/CoreHelpers.Extensions.Logging.Tasks/TaskLoggerProvider.cs

@@ -7,6 +7,7 @@ namespace CoreHelpers.Extensions.Logging.Tasks
     internal class TaskLoggerProvider : ILoggerProvider
 	{
         private ITaskLoggerFactory _taskLoggerFactory;
+        private ILogger? _activeLogger = null;
 
         public TaskLoggerProvider(ITaskLoggerFactory taskLoggerFactory)
 		{
@@ -15,7 +16,10 @@ public TaskLoggerProvider(ITaskLoggerFactory taskLoggerFactory)
 
         public ILogger CreateLogger(string categoryName)
         {
-            return new TaskLogger(_taskLoggerFactory);
+            if (_activeLogger == null)
+                _activeLogger = new TaskLogger(_taskLoggerFactory);
+
+            return _activeLogger;
         }
 
         public void Dispose()

dotNet/CoreHelpers.TaskLogging.Sample/IProcessor.cs

@@ -0,0 +1,9 @@
+using System;
+namespace CoreHelpers.TaskLogging.Sample
+{
+	internal interface IProcessor
+	{
+		Task Execute();
+	}
+}
+

dotNet/CoreHelpers.TaskLogging.Sample/ProcessorFailed.cs

@@ -0,0 +1,35 @@
+using System;
+using Microsoft.Extensions.Logging;
+
+namespace CoreHelpers.TaskLogging.Sample
+{
+	internal class ProcessorFailed : IProcessor
+    {
+        private ILogger<ProcessorFailed> _logger;
+
+
+        public ProcessorFailed(ILogger<ProcessorFailed> logger)
+		{
+            _logger = logger;
+		}
+
+        public async Task Execute()
+        {
+            await Task.CompletedTask;
+
+            try
+            {
+                // log some lines
+                for (int i = 0; i < 10; i++)
+                    _logger.LogInformation($"{i} Hello World Task 2");
+
+                throw new Exception("I failed!");
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(e, "Unknown Error");
+            }
+        }
+    }
+}
+

dotNet/CoreHelpers.TaskLogging.Sample/ProcessorSuccess.cs

@@ -0,0 +1,23 @@
+using System;
+using Microsoft.Extensions.Logging;
+
+namespace CoreHelpers.TaskLogging.Sample
+{
+	internal class ProcessorSuccess : IProcessor
+    {
+        private ILogger<ProcessorSuccess> _logger;
+
+
+        public ProcessorSuccess(ILogger<ProcessorSuccess> logger)
+		{
+            _logger = logger;
+		}
+
+        public async Task Execute()
+        {
+            _logger.LogInformation("Hello from the processor");
+            await Task.CompletedTask;
+        }
+    }
+}
+

dotNet/CoreHelpers.TaskLogging.Sample/Program.cs

@@ -4,6 +4,7 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using CoreHelpers.Extensions.Logging.Tasks;
+using CoreHelpers.TaskLogging.Sample;
 
 // configure the services that they us the emulator
 HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
@@ -17,73 +18,17 @@
         .AddConsole()
         .AddTaskLogger());
 
+builder.Services.AddTransient<IProcessor, ProcessorSuccess>();
+builder.Services.AddTransient<IProcessor, ProcessorFailed>();
+builder.Services.AddTransient<Worker>();
+
 // build the host
 using IHost host = builder.Build();
 
-// get the task logger factory
-var taskLoggerFactory = host.Services.GetService<ITaskLoggerFactory>();
-if (taskLoggerFactory == null)
-    throw new NullReferenceException();
-
-
-// define a bit meta data
-var metaData = new Dictionary<string, string>()
-{
-    { "app", "CoreHelpers.TaskLogging.Sample"},
-    { "class", "Main"}
-};
-
-// Announce a new task in the system
-var taskId = await taskLoggerFactory.AnnounceTask("SyncMyMails", "q:Queue01", "Container01", metaData);
-
-// ... this is the place where the application can do other topics, be aware
-// the task is still announced and exists as pending task ...
-
-// get a logger factory
-var loggerFactory = host.Services.GetService<ILoggerFactory>();
-if (loggerFactory == null)
+// get the worker
+var worker = host.Services.GetService<Worker>();
+if (worker == null)
     throw new NullReferenceException();
 
-// get a logger
-var logger = loggerFactory.CreateLogger("Main");
-
-// generate scope
-using(logger.BeginScope("This is just a scope"))
-{
-    using(logger.BeginScope("This is just another scope"))
-    {
-        // after this using all what is logged becomes part of the
-        // task context
-        using(logger.BeginTaskScope(taskId))
-        {
-            // log some lines
-            for (int i = 0; i < 500; i++)
-                logger.LogInformation($"{i} Hello World Task 1");
-        }      
-    }
-
-    // announce the second task
-    var taskId2 = await taskLoggerFactory.AnnounceTask("SomethingElseWithErrors", "q:Queue01", "Container01");
-
-    // this would be a second task
-    using (logger.BeginTaskScope(taskId2))
-    {
-        try
-        {
-            // log some lines
-            for (int i = 0; i < 10; i++)
-                logger.LogInformation($"{i} Hello World Task 2");
-
-            throw new Exception("I failed!");
-        } catch (Exception e)
-        {
-            logger.LogError(e, "Unknown Error");
-        }
-    }
-}
-
-// generate a new task the system never announced before
-using(logger.BeginNewTaskScope("NewTask", "Q:Q2", "Cnt02"))
-{
-    logger.LogInformation("hello new task");
-}
+// execute the work
+await worker.Process();

dotNet/CoreHelpers.TaskLogging.Sample/Worker.cs

@@ -0,0 +1,50 @@
+using System;
+using Microsoft.Extensions.Logging;
+using CoreHelpers.Extensions.Logging.Tasks;
+
+namespace CoreHelpers.TaskLogging.Sample
+{
+	internal class Worker
+	{
+		private ILogger<Worker> _logger;
+		private IEnumerable<IProcessor> _processors;
+        private ITaskLoggerFactory _taskLoggerFactory;
+
+        public Worker(ILogger<Worker> logger, IEnumerable<IProcessor> processors, ITaskLoggerFactory taskLoggerFactory)
+		{
+			_logger = logger;
+			_processors = processors;
+            _taskLoggerFactory = taskLoggerFactory;
+        }
+
+		public async Task Process()
+		{           
+            // execute the successprocessor
+            using (_logger.BeginNewTaskScope("successjob", "q", "w"))
+			{				
+				await _processors.Where(p => p is ProcessorSuccess).First().Execute();								
+			}
+
+            // execute the failedprocessor
+            using (_logger.BeginNewTaskScope("failedjob", "q", "w"))
+            {
+                await _processors.Where(p => p is ProcessorFailed).First().Execute();
+            }
+
+            // execute the succssprocesssor with announcement            
+            var metaData = new Dictionary<string, string>()
+            {
+                { "app", "CoreHelpers.TaskLogging.Sample"},
+                { "class", "Main"}
+            };
+
+            var taskId = await _taskLoggerFactory.AnnounceTask("announcejob", "q", "w", metaData);
+
+            using (_logger.BeginTaskScope(taskId))
+            {
+                await _processors.Where(p => p is ProcessorSuccess).First().Execute();
+            }
+        }
+    }
+}
+