added message group support

WildernessLabs · Jan 22, 2024 · 57202dd · 57202dd
1 parent 9bd205c
commit 57202dd
Show file tree

Hide file tree

Showing 7 changed files with 124 additions and 56 deletions.
diff --git a/Source/Meadow.Logging.LogProviders/Driver/CloudLogger.cs b/Source/Meadow.Logging.LogProviders/Driver/CloudLogger.cs
@@ -1,11 +1,11 @@
+using Meadow.Cloud;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
-using Meadow.Cloud;
 
 namespace Meadow.Logging;
 
@@ -33,7 +33,7 @@ public CloudLogger(LogLevel level = LogLevel.Information)
             using FileStream fs = File.Create(LogFilePath);
             fs.Close();
         }
-        
+
         EventFilePath = Path.Combine(Resolver.Device.PlatformOS.FileSystem.DocumentsDirectory, "events.log");
         if (!File.Exists(EventFilePath))
         {
@@ -54,14 +54,11 @@ public CloudLogger(LogLevel level = LogLevel.Information)
     /// Current minimum level for the CloudLogger
     /// </summary>
     public LogLevel MinLevel { get; protected set; }
-    static SemaphoreSlim semaphoreSlim = new SemaphoreSlim(1, 1);
 
-    /// <summary>
-    /// Send a log message to Meadow.Cloud.
-    /// </summary>
-    /// <param name="level">LogLevel</param>
-    /// <param name="message">Message of the log</param>
-    public async void Log(LogLevel level, string message)
+    private static SemaphoreSlim semaphoreSlim = new SemaphoreSlim(1, 1);
+
+    /// <inheritdoc/>
+    public async void Log(LogLevel level, string message, string? _)
     {
         if (level >= MinLevel)
         {
@@ -71,7 +68,7 @@ public async void Log(LogLevel level, string message)
                 Message = message,
                 Timestamp = DateTime.UtcNow
             };
-            
+
             await Send(LogFilePath, cloudLog, Resolver.MeadowCloudService.SendLog);
         }
     }
@@ -89,7 +86,7 @@ public async void LogException(Exception ex)
             Message = ex.Message,
             Timestamp = DateTime.UtcNow
         };
-        
+
         await Send(LogFilePath, log, Resolver.MeadowCloudService.SendLog);
     }
 
@@ -108,14 +105,14 @@ public async void LogEvent(int eventId, string description, Dictionary<string, o
             Measurements = measurements,
             Timestamp = DateTime.UtcNow
         };
-        
+
         await Send(EventFilePath, cloudEvent, Resolver.MeadowCloudService.SendEvent);
     }
 
     private async Task Send<T>(string file, T item, Func<T, Task> sendFunc)
     {
         var serializeOptions = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
-        
+
         var connected = Resolver.Device.NetworkAdapters.Any(a => a.IsConnected);
 
         if (connected)

diff --git a/Source/Meadow.Logging.LogProviders/Driver/FileLogger.cs b/Source/Meadow.Logging.LogProviders/Driver/FileLogger.cs
@@ -36,7 +36,7 @@ public FileLogger(LogLevel minimumLogLevel = LogLevel.Warning)
     }
 
     /// <inheritdoc/>
-    public void Log(LogLevel level, string message)
+    public void Log(LogLevel level, string message, string? _)
     {
         if (level != LogLevel.None && level >= MinimumLogLevel)
         {

diff --git a/Source/Meadow.Logging.LogProviders/Driver/UdpLogger.cs b/Source/Meadow.Logging.LogProviders/Driver/UdpLogger.cs
@@ -31,7 +31,7 @@ public UdpLogger(int port = 5100, char delimiter = '\t')
         }
 
         /// <inheritdoc/>
-        public void Log(LogLevel level, string message)
+        public void Log(LogLevel level, string message, string? _)
         {
             var payload = Encoding.UTF8.GetBytes($"{level}{_delimiter}{message}\n");
             _client.Send(payload, payload.Length, _broadcast);

diff --git a/Source/Meadow.Logging/lib/ConsoleLogProvider.cs b/Source/Meadow.Logging/lib/ConsoleLogProvider.cs
@@ -10,22 +10,37 @@ public class ConsoleLogProvider : ILogProvider
         /// <summary>
         /// When true, the current log level will be prefixed to all logged messages
         /// </summary>
-        public bool ShowLoglevel { get; set; } = false;
+        public bool ShowLogLevel { get; set; } = false;
 
         /// <summary>
-        /// Called when the associated Logger has a message call
+        /// When true, the current message group will be prefixed to all logged messages
         /// </summary>
-        /// <param name="level">The LogLevel for the message</param>
-        /// <param name="message">The message to log</param>
-        public void Log(LogLevel level, string message)
+        public bool ShowMessageGroup { get; set; } = false;
+
+        /// <inheritdoc/>
+        public void Log(LogLevel level, string message, string? messageGroup)
         {
-            if (ShowLoglevel)
+            if (ShowLogLevel)
             {
-                Console.WriteLine($"{level.ToString().ToUpper()}: {message}");
+                if (ShowMessageGroup)
+                {
+                    Console.WriteLine($"({messageGroup}) {level.ToString().ToUpper()}: {message}");
+                }
+                else
+                {
+                    Console.WriteLine($"{level.ToString().ToUpper()}: {message}");
+                }
             }
             else
             {
-                Console.WriteLine($"{message}");
+                if (ShowMessageGroup)
+                {
+                    Console.WriteLine($"({messageGroup}) {message}");
+                }
+                else
+                {
+                    Console.WriteLine($"{message}");
+                }
             }
         }
     }

diff --git a/Source/Meadow.Logging/lib/DebugLogProvider.cs b/Source/Meadow.Logging/lib/DebugLogProvider.cs
@@ -5,14 +5,10 @@
     /// </summary>
     public class DebugLogProvider : ILogProvider
     {
-        /// <summary>
-        /// Called when the associated Logger has a message call
-        /// </summary>
-        /// <param name="level">The LogLevel for the message</param>
-        /// <param name="message">The message to log</param>
-        public void Log(LogLevel level, string message)
+        /// <inheritdoc/>
+        public void Log(LogLevel level, string message, string? messageGroup)
         {
-            System.Diagnostics.Debug.WriteLine($"{level.ToString().ToUpper()}: {message}");
+            System.Diagnostics.Debug.WriteLine($"({messageGroup}){level.ToString().ToUpper()}: {message}");
         }
     }
 }
diff --git a/Source/Meadow.Logging/lib/ILogProvider.cs b/Source/Meadow.Logging/lib/ILogProvider.cs
@@ -10,6 +10,7 @@ public interface ILogProvider
         /// </summary>
         /// <param name="level">The LogLevel for the message</param>
         /// <param name="message">The message to log</param>
-        void Log(LogLevel level, string message);
+        /// <param name="messageGroup">The (optional) log message groupd</param>
+        void Log(LogLevel level, string message, string? messageGroup);
     }
 }
diff --git a/Source/Meadow.Logging/lib/Logger.cs b/Source/Meadow.Logging/lib/Logger.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace Meadow.Logging;
 
@@ -7,10 +8,44 @@ namespace Meadow.Logging;
 /// </summary>
 public class Logger
 {
-    private LogProviderCollection _providers = new LogProviderCollection();
+    /// <summary>
+    /// Defines message groups for categorizing log messages.
+    /// </summary>
+    public static class MessageGroup
+    {
+        /// <summary>
+        /// Represents all log messages.
+        /// </summary>
+        public const string All = "all";
+
+        /// <summary>
+        /// Represents the operating system-related log messages.
+        /// </summary>
+        public const string OS = "os";
+
+        /// <summary>
+        /// Represents the core system-related log messages.
+        /// </summary>
+        public const string Core = "core";
+
+        /// <summary>
+        /// Represents the application-specific log messages.
+        /// </summary>
+        public const string Application = "application";
+    }
+
+    private LogProviderCollection _providers = new();
 
     private readonly int _startupTicks;
 
+    /// <summary>
+    /// Gets the list of groups used for displaying log messages.
+    /// </summary>
+    /// <remarks>
+    /// To show message from all groups, either use `MessageGroup.All` <i>or</i> clear the ShowsGroups list
+    /// </remarks>
+    public List<string> ShowGroups { get; } = new();
+
     /// <summary>
     /// Gets or sets a value indicating whether to show ticks in log messages
     /// </summary>
@@ -27,6 +62,8 @@ public class Logger
     /// <param name="providers">A collection of providers to add to the Logger</param>
     public Logger(params ILogProvider[] providers)
     {
+        ShowGroups.Add(MessageGroup.Application);
+
         foreach (var p in providers)
         {
             AddProvider(p);
@@ -66,110 +103,132 @@ public void AddProvider(ILogProvider provider)
     /// Sends a Trace-level message to all ILogProviders
     /// </summary>
     /// <param name="message">The message to send to Providers</param>
-    public void Trace(string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void Trace(string message, string? messageGroup = null)
     {
-        Log(LogLevel.Trace, message);
+        Log(LogLevel.Trace, message, messageGroup);
     }
 
     /// <summary>
     /// Conditionally sends a Trace-level message to all ILogProviders
     /// </summary>
     /// <param name="condition">The message will be sent to Providers only when this is true</param>
     /// <param name="message">The message to send to Providers</param>
-    public void TraceIf(bool condition, string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void TraceIf(bool condition, string message, string? messageGroup = null)
     {
-        if (condition) Log(LogLevel.Trace, message);
+        if (condition) Log(LogLevel.Trace, message, messageGroup);
     }
 
     /// <summary>
     /// Sends a Debug-level message to all ILogProviders
     /// </summary>
     /// <param name="message">The message to send to Providers</param>
-    public void Debug(string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void Debug(string message, string? messageGroup = null)
     {
-        Log(LogLevel.Debug, message);
+        Log(LogLevel.Debug, message, messageGroup);
     }
 
     /// <summary>
     /// Conditionally sends a Debug-level message to all ILogProviders
     /// </summary>
     /// <param name="condition">The message will be sent to Providers only when this is true</param>
     /// <param name="message">The message to send to Providers</param>
-    public void DebugIf(bool condition, string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void DebugIf(bool condition, string message, string? messageGroup = null)
     {
-        if (condition) Log(LogLevel.Debug, message);
+        if (condition) Log(LogLevel.Debug, message, messageGroup);
     }
 
     /// <summary>
     /// Sends an Info-level message to all ILogProviders
     /// </summary>
     /// <param name="message">The message to send to Providers</param>
-    public void Info(string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void Info(string message, string? messageGroup = null)
     {
-        Log(LogLevel.Information, message);
+        Log(LogLevel.Information, message, messageGroup);
     }
 
     /// <summary>
     /// Conditionally sends a Info-level message to all ILogProviders
     /// </summary>
     /// <param name="condition">The message will be sent to Providers only when this is true</param>
     /// <param name="message">The message to send to Providers</param>
-    public void InfoIf(bool condition, string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void InfoIf(bool condition, string message, string? messageGroup = null)
     {
-        if (condition) Log(LogLevel.Information, message);
+        if (condition) Log(LogLevel.Information, message, messageGroup);
     }
 
     /// <summary>
     /// Sends a Warn-level message to all ILogProviders
     /// </summary>
     /// <param name="message">The message to send to Providers</param>
-    public void Warn(string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void Warn(string message, string? messageGroup = null)
     {
-        Log(LogLevel.Warning, message);
+        Log(LogLevel.Warning, message, messageGroup);
     }
 
     /// <summary>
     /// Conditionally sends a Warn-level message to all ILogProviders
     /// </summary>
     /// <param name="condition">The message will be sent to Providers only when this is true</param>
     /// <param name="message">The message to send to Providers</param>
-    public void WarnIf(bool condition, string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void WarnIf(bool condition, string message, string? messageGroup = null)
     {
-        if (condition) Log(LogLevel.Warning, message);
+        if (condition) Log(LogLevel.Warning, message, messageGroup);
     }
 
     /// <summary>
     /// Sends a Error-level message to all ILogProviders
     /// </summary>
     /// <param name="exception">The exception to translate and send to Providers</param>
-    public void Error(Exception exception)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void Error(Exception exception, string? messageGroup = null)
     {
-        Log(LogLevel.Error, exception.ToString());
+        Log(LogLevel.Error, exception.ToString(), messageGroup);
     }
 
     /// <summary>
     /// Sends a Error-level message to all ILogProviders
     /// </summary>
     /// <param name="message">The message to send to Providers</param>
-    public void Error(string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void Error(string message, string? messageGroup = null)
     {
-        Log(LogLevel.Error, message);
+        Log(LogLevel.Error, message, messageGroup);
     }
 
     /// <summary>
     /// Conditionally sends a Error-level message to all ILogProviders
     /// </summary>
     /// <param name="condition">The message will be sent to Providers only when this is true</param>
     /// <param name="message">The message to send to Providers</param>
-    public void ErrorIf(bool condition, string message)
+    /// <param name="messageGroup">The (optional) message group</param>
+    public void ErrorIf(bool condition, string message, string? messageGroup = null)
     {
-        if (condition) Log(LogLevel.Error, message);
+        if (condition) Log(LogLevel.Error, message, messageGroup);
     }
 
-    private void Log(LogLevel level, string message)
+    private void Log(LogLevel level, string message, string? messageGroup)
     {
         if (LogLevel > level) return;
 
+        if (messageGroup == null) messageGroup = MessageGroup.Application;
+
+        if (ShowGroups.Count > 0)
+        {
+            if (!ShowGroups.Contains(MessageGroup.All)
+                && !ShowGroups.Contains(messageGroup))
+            {
+                return;
+            }
+        }
+
         TimeSpan? now = null;
 
         lock (_providers)
@@ -186,7 +245,7 @@ private void Log(LogLevel level, string message)
                     message = $"[+{now:h\\:m\\:ss\\.FFF}] {message}";
                 }
 
-                p.Log(level, message);
+                p.Log(level, message, messageGroup);
             }
         }
     }