added support for meta data logging

Author: dei79

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

@@ -36,7 +36,19 @@ public TaskLogger(ITaskLoggerFactory taskLoggerFactory)
             // check if we need to announce the task
             if (!castedState.IsTaskAnnounced)
             {
-                castedState.TaskId = _taskLoggerFactory.AnnounceTask(castedState.TaskType, castedState.TaskSource, castedState.TaskWorker).GetAwaiter().GetResult();
+                if (String.IsNullOrEmpty(castedState.MetaData))
+                {
+                    castedState.TaskId = _taskLoggerFactory
+                        .AnnounceTask(castedState.TaskType, castedState.TaskSource, castedState.TaskWorker).GetAwaiter()
+                        .GetResult();
+                }
+                else
+                {
+                    castedState.TaskId = _taskLoggerFactory
+                        .AnnounceTask(castedState.TaskType, castedState.TaskSource, castedState.TaskWorker, castedState.MetaData).GetAwaiter()
+                        .GetResult();
+                }
+
                 castedState.IsTaskAnnounced = true;
             }
 

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

@@ -17,8 +17,14 @@ public static ILoggingBuilder AddTaskLogger(this ILoggingBuilder builder)
         public static ITaskLoggerTypedScope? BeginTaskScope(this ILogger logger, string taskId)
             => BeginTypedTaskScope(logger, new TaskLoggerState() { TaskId = taskId, IsTaskAnnounced = true });
 
+        public static ITaskLoggerTypedScope? BeginTaskScope(this ILogger logger, string taskId, string metaDataString)
+            => BeginTypedTaskScope(logger, new TaskLoggerState() { TaskId = taskId, IsTaskAnnounced = true, MetaData = metaDataString });
+        
         public static ITaskLoggerTypedScope? BeginNewTaskScope(this ILogger logger, string taskType, string taskSource, string taskWorker)
             => BeginTypedTaskScope(logger, new TaskLoggerState() { TaskId = string.Empty, TaskType = taskType, TaskSource = taskSource, TaskWorker = taskWorker, IsTaskAnnounced = false });
+        
+        public static ITaskLoggerTypedScope? BeginNewTaskScope(this ILogger logger, string taskType, string taskSource, string taskWorker, string metaDataString)
+            => BeginTypedTaskScope(logger, new TaskLoggerState() { TaskId = string.Empty, TaskType = taskType, TaskSource = taskSource, TaskWorker = taskWorker, IsTaskAnnounced = false, MetaData = metaDataString });
 
         private static ITaskLoggerTypedScope? BeginTypedTaskScope(ILogger logger, TaskLoggerState taskLoggerState)
         {

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

@@ -8,6 +8,8 @@ internal class TaskLoggerState
 		public string TaskType {get; set;} = string.Empty;
         public string TaskSource { get; set; } = string.Empty;
 		public string TaskWorker { get; set; } = string.Empty;
+		
+		public string MetaData { get; set; } = string.Empty;
 		public bool IsTaskAnnounced { get; set; } = false;
     }
 }

dotNet/CoreHelpers.TaskLogging.Abstractions/ITaskLoggerFactory.cs

@@ -42,7 +42,19 @@ public interface ITaskLoggerFactory
         /// <param name="taskWorker"></param>
         /// <param name="metaData"></param>
         /// <returns></returns>
-        Task<string> AnnounceTask(string taskType, string taskSource, string taskWorker, IDictionary<string, string> metaData);
+        Task<string> AnnounceTask(string taskType, string taskSource, string taskWorker, string metaData);
+        
+        /// <summary>
+        /// Announces a new task in the state pending to the logging framework including required
+        /// meta data usable in the frontend. Only announced tasks can be used in a task logger by
+        /// calling CreateTaskLogger
+        /// </summary>
+        /// <param name="taskType"></param>
+        /// <param name="taskSource"></param>
+        /// <param name="taskWorker"></param>
+        /// <param name="metaDataTyped"></param>
+        /// <returns></returns>
+        Task<string> AnnounceTask(string taskType, string taskSource, string taskWorker, IDictionary<string, string> metaDataTyped);
 
         /// <summary>
         /// Update the task status of a given task

dotNet/CoreHelpers.TaskLogging.Sample/Worker.cs

@@ -6,9 +6,9 @@ namespace CoreHelpers.TaskLogging.Sample
 {
 	internal class Worker
 	{
-		private ILogger<Worker> _logger;
-		private IEnumerable<IProcessor> _processors;
-        private ITaskLoggerFactory _taskLoggerFactory;
+		private readonly ILogger<Worker> _logger;
+		private readonly IEnumerable<IProcessor> _processors;
+        private readonly ITaskLoggerFactory _taskLoggerFactory;
 
         public Worker(ILogger<Worker> logger, IEnumerable<IProcessor> processors, ITaskLoggerFactory taskLoggerFactory)
 		{
@@ -19,14 +19,14 @@ public Worker(ILogger<Worker> logger, IEnumerable<IProcessor> processors, ITaskL
 
 		public async Task Process()
 		{           
-            // execute the successprocessor
+            // execute the success processor
             using (_logger.BeginNewTaskScope("successjob", "q", "w"))
 			{				
 				await _processors.Where(p => p is ProcessorSuccess).First().Execute();								
 			}
 
             // execute the failedprocessor
-            using (var scope = _logger.BeginNewTaskScope("failedjob", "q", "w"))
+            using (var scope = _logger.BeginNewTaskScope("failedjob", "q", "w", "app=CoreHelpers.TaskLogging.Sample,class=Main"))
             {
 	            Console.WriteLine(scope.TaskId);
                 await _processors.Where(p => p is ProcessorFailed).First().Execute();

dotNet/CoreHelpers.TaskLogging/AzureStorageTableTaskLoggerFactory.cs

@@ -24,9 +24,9 @@ public AzureStorageTableTaskLoggerFactory(string connectionString, string enviro
         }
 
         public async Task<string> AnnounceTask(string taskType, string taskSource, string taskWorker)
-            => await AnnounceTask(taskType, taskSource, taskWorker, new Dictionary<string, string>());
+            => await AnnounceTask(taskType, taskSource, taskWorker, string.Empty);
 
-        public async Task<string> AnnounceTask(string taskType, string taskSource, string taskWorker, IDictionary<string, string>? metaData)
+        public async Task<string> AnnounceTask(string taskType, string taskSource, string taskWorker, string metaData)
         {
             // define the refDate
             var refDate = DateTime.UtcNow;
@@ -44,7 +44,7 @@ public async Task<string> AnnounceTask(string taskType, string taskSource, strin
                 TaskType = taskType,
                 TaskSource = taskSource,
                 TaskWorker = taskWorker,
-                TaskData = metaData != null ? JsonConvert.SerializeObject(metaData) : String.Empty
+                TaskData = String.IsNullOrEmpty(metaData) ? string.Empty : metaData
             };
 
             // get the table name
@@ -57,6 +57,9 @@ public async Task<string> AnnounceTask(string taskType, string taskSource, strin
             return taskKey;
         }
 
+        public Task<string> AnnounceTask(string taskType, string taskSource, string taskWorker, IDictionary<string, string> metaDataTyped)
+            => AnnounceTask(taskType, taskSource, taskWorker, JsonConvert.SerializeObject(metaDataTyped));
+        
         public async Task UpdateTaskStatus(string taskKey, TaskStatus taskStatus)
         {            
             // build the task entity