Merge branch 'master' of https://git.saey.me/EonaCat/EonaCat.Logger

EonaCat.Logger/EonaCat.Logger.csproj

@@ -3,7 +3,7 @@
     <TargetFrameworks>.netstandard2.1; net6.0; net7.0; net8.0; net4.8;</TargetFrameworks>
     <ApplicationIcon>icon.ico</ApplicationIcon>
 	<LangVersion>latest</LangVersion>
-    <FileVersion>1.3.2</FileVersion>
+    <FileVersion>1.3.5</FileVersion>
     <Authors>EonaCat (Jeroen Saey)</Authors>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <Company>EonaCat (Jeroen Saey)</Company>
@@ -24,7 +24,7 @@
   </PropertyGroup>
 
 	<PropertyGroup>
-		<EVRevisionFormat>1.3.2+{chash:10}.{c:ymd}</EVRevisionFormat>
+		<EVRevisionFormat>1.3.5+{chash:10}.{c:ymd}</EVRevisionFormat>
 		<EVDefault>true</EVDefault>
 		<EVInfo>true</EVInfo>
 		<EVTagMatch>v[0-9]*</EVTagMatch>

EonaCat.Logger/Extensions/ExceptionExtensions.cs

@@ -63,10 +63,17 @@ public static class ExceptionExtensions
 
         foreach (DictionaryEntry entry in data)
         {
-            sb.Append("  | ")
+            if (entry.Key != null)
-                .Append(entry.Key)
+            {
-                .Append(": ")
+                sb.Append("  | ")
+                .Append(entry.Key);
+            }
+
+            if (entry.Value != null)
+            {
+                sb.Append(": ")
                 .AppendLine(entry.Value.ToString());
+            }
         }
 
         return sb.ToString();

EonaCat.Logger/GrayLog/GrayLogServer.cs

@@ -77,6 +77,8 @@ public class GrayLogServer
     /// </summary>
     public string IpPort => _Hostname + ":" + _Port;
 
+    public bool SupportsTcp { get; set; }
+
     private void SetUdp()
     {
         Udp = null;

EonaCat.Logger/Managers/LogHelper.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net;
+using System.Net.Sockets;
 using System.Text;
 using System.Threading.Tasks;
 using EonaCat.Json;
@@ -25,89 +27,51 @@ internal static class LogHelper
 {
     internal static event EventHandler<ErrorMessage> OnException;
 
+    internal static event EventHandler<ErrorMessage> OnLogLevelDisabled;
+
+    private static readonly string MachineName = Environment.MachineName;
+    private static readonly string HostName = Dns.GetHostName();
+
     internal static string FormatMessageWithHeader(LoggerSettings settings, ELogType logType, string currentMessage,
         DateTime dateTime, string category = null)
     {
-        if (string.IsNullOrWhiteSpace(currentMessage))
+        if (string.IsNullOrWhiteSpace(currentMessage)) return currentMessage;
-        {
-            return currentMessage;
-        }
-
-        if (string.IsNullOrWhiteSpace(category))
-        {
-            category = "General";
-        }
 
+        category ??= "General";
         var sb = new StringBuilder(settings?.HeaderFormat ?? "[EonaCatLogger]");
+        var timestamp = dateTime.ToString(settings?.TimestampFormat ?? "yyyy-MM-dd HH:mm:ss");
+        var timeLabel = settings?.UseLocalTime ?? false ? "[LOCAL]" : "[UTC]";
 
-        sb.Replace("{ts}",
+        sb.Replace("{ts}", $"{timestamp} {timeLabel}")
-                dateTime.ToString(settings?.TimestampFormat ?? "yyyy-MM-dd HH:mm:ss") + " " +
+            .Replace("{host}", $"[Host:{HostName}]")
-                (settings?.UseLocalTime ?? false ? "[LOCAL]" : "[UTC]"))
-            .Replace("{host}", $"[Host:{Dns.GetHostName()}]")
             .Replace("{category}", $"[Category:{category}]")
             .Replace("{thread}", $"[ThreadId:{Environment.CurrentManagedThreadId}]")
             .Replace("{sev}", $"[{logType}]");
 
-        if (!settings?.RemoveMessagePrefix ?? (false && !currentMessage.Contains("[EonaCatLogger]")))
+        if (!(settings?.RemoveMessagePrefix ?? false) && !currentMessage.Contains("[EonaCatLogger]"))
         {
             sb.Insert(0, "[EonaCatLogger] ");
         }
 
         sb.Append(" ").Append(currentMessage);
-
         return sb.ToString();
     }
 
     internal static void SendToConsole(LoggerSettings settings, ELogType logType, string message, bool writeToConsole)
     {
-        if (settings == null || !writeToConsole || string.IsNullOrWhiteSpace(message))
+        if (settings == null || !writeToConsole || string.IsNullOrWhiteSpace(message)) return;
-        {
-            return;
-        }
 
         if (settings.EnableColors && settings.Colors != null)
         {
             var prevForeground = Console.ForegroundColor;
             var prevBackground = Console.BackgroundColor;
 
-            ConsoleColor foregroundColor;
+            if (TryGetLogColor(settings.Colors, logType, out var foregroundColor, out var backgroundColor))
-            ConsoleColor backgroundColor;
-            switch (logType)
             {
-                case ELogType.DEBUG:
+                Console.ForegroundColor = foregroundColor;
-                    foregroundColor = settings.Colors.Debug.Foreground;
+                Console.BackgroundColor = backgroundColor;
-                    backgroundColor = settings.Colors.Debug.Background;
-                    break;
-                case ELogType.INFO:
-                    foregroundColor = settings.Colors.Info.Foreground;
-                    backgroundColor = settings.Colors.Info.Background;
-                    break;
-                case ELogType.WARNING:
-                    foregroundColor = settings.Colors.Warning.Foreground;
-                    backgroundColor = settings.Colors.Warning.Background;
-                    break;
-                case ELogType.ERROR:
-                    foregroundColor = settings.Colors.Error.Foreground;
-                    backgroundColor = settings.Colors.Error.Background;
-                    break;
-                case ELogType.TRAFFIC:
-                    foregroundColor = settings.Colors.Traffic.Foreground;
-                    backgroundColor = settings.Colors.Traffic.Background;
-                    break;
-                case ELogType.CRITICAL:
-                    foregroundColor = settings.Colors.Critical.Foreground;
-                    backgroundColor = settings.Colors.Critical.Background;
-                    break;
-                case ELogType.TRACE:
-                    foregroundColor = settings.Colors.Trace.Foreground;
-                    backgroundColor = settings.Colors.Trace.Background;
-                    break;
-                default:
-                    return;
             }
 
-            Console.ForegroundColor = foregroundColor;
-            Console.BackgroundColor = backgroundColor;
             Console.WriteLine(message);
             Console.ForegroundColor = prevForeground;
             Console.BackgroundColor = prevBackground;
@@ -118,24 +82,60 @@ internal static class LogHelper
         }
     }
 
-    internal static void SendToFile(ILogger logger, LoggerSettings settings, ELogType logType, string message)
+    private static bool TryGetLogColor(ColorSchema colors, ELogType logType, out ConsoleColor foreground, out ConsoleColor background)
     {
-        if (logger == null || settings == null || !settings.EnableFileLogging ||
+        foreground = default;
-            string.IsNullOrWhiteSpace(message))
+        background = default;
-        {
-            return;
-        }
 
-        var logLevel = logType.ToLogLevel();
+        return logType switch
-        if (IsLogLevelEnabled(settings, logType))
         {
-            Log(logger, logLevel, message);
+            ELogType.DEBUG => TrySetColors(colors.Debug, out foreground, out background),
-        }
+            ELogType.INFO => TrySetColors(colors.Info, out foreground, out background),
+            ELogType.WARNING => TrySetColors(colors.Warning, out foreground, out background),
+            ELogType.ERROR => TrySetColors(colors.Error, out foreground, out background),
+            ELogType.TRAFFIC => TrySetColors(colors.Traffic, out foreground, out background),
+            ELogType.CRITICAL => TrySetColors(colors.Critical, out foreground, out background),
+            ELogType.TRACE => TrySetColors(colors.Trace, out foreground, out background),
+            _ => false,
+        };
     }
 
-    private static bool IsLogLevelEnabled(LoggerSettings settings, ELogType logType)
+    private static bool TrySetColors(ColorScheme color, out ConsoleColor foreground, out ConsoleColor background)
     {
-        return settings.MaxLogType != ELogType.NONE && logType <= settings.MaxLogType;
+        foreground = color.Foreground;
+        background = color.Background;
+        return true;
+    }
+
+    internal static void SendToFile(ILogger logger, LoggerSettings settings, ELogType logType, string message)
+    {
+        if (logger == null || settings == null || !settings.EnableFileLogging || string.IsNullOrWhiteSpace(message)) return;
+
+        if (IsLogLevelEnabled(settings, logType))
+        {
+            Log(logger, logType.ToLogLevel(), message);
+        }
+    }
+    private static bool IsLogLevelEnabled(LoggerSettings loggerSettings, ELogType logType)
+    {
+        if (loggerSettings == null)
+        {
+            OnLogLevelDisabled?.Invoke(null, new ErrorMessage { Message = "Settings is null." });
+            return false;
+        }
+
+        var isEnabled = loggerSettings.MaxLogType != ELogType.NONE && logType <= loggerSettings.MaxLogType;
+        if (!isEnabled)
+        {
+            OnLogLevelDisabled?.Invoke(null, new ErrorMessage { Message = $"Logtype '{logType}' is not enabled." });
+        }
+
+        return isEnabled;
+    }
+
+    public static void SetLogLevel(LoggerSettings settings, ELogType logType)
+    {
+        settings.MaxLogType = logType;
     }
 
     private static void Log(ILogger logger, LogLevel logLevel, string message)
@@ -143,61 +143,38 @@ internal static class LogHelper
         logger.Log(logLevel, message);
     }
 
-    public static async Task SendToSplunkServersAsync(LoggerSettings settings, SplunkPayload splunkPayload,
+    public static async Task SendToSplunkServersAsync(LoggerSettings settings, SplunkPayload splunkPayload, bool sendToSplunkServer)
-        bool sendToSplunkServer)
     {
         if (settings == null || !sendToSplunkServer || splunkPayload == null)
         {
             return;
         }
 
-        if (settings.SplunkServers == null)
+        var tasks = settings.SplunkServers?
-        {
+            .Where(splunkServer => splunkServer.HasHecUrl && splunkServer.HasHecToken)
-            settings.SplunkServers = new List<SplunkServer.SplunkServer>();
+            .Select(async splunkServer =>
-        }
-
-        foreach (var splunkServer in settings.SplunkServers)
-        {
-            if (!splunkServer.HasHecUrl || !splunkServer.HasHecToken)
             {
-                OnException?.Invoke(null,
+                try
-                    new ErrorMessage
-                    {
-                        Message =
-                            $"Splunk server HecUrl or HecToken not specified, skipping splunkServer '{splunkServer.SplunkHecUrl}'"
-                    });
-                continue;
-            }
-
-            try
-            {
-                var response = await splunkServer.SendAsync(splunkPayload);
-
-                if (!response.IsSuccessStatusCode)
                 {
-                    OnException?.Invoke(null,
+                    var response = await splunkServer.SendAsync(splunkPayload);
-                        new ErrorMessage
+                    if (!response.IsSuccessStatusCode)
-                        {
-                            Message =
-                                $"Failed to send log to Splunk '{splunkServer.SplunkHecUrl}'. Status code: {response.StatusCode}"
-                        });
-                }
-            }
-            catch (Exception exception)
-            {
-                OnException?.Invoke(null,
-                    new ErrorMessage
                     {
-                        Exception = exception,
+                        LogError($"Failed to send log to Splunk '{splunkServer.SplunkHecUrl}'. Status code: {response.StatusCode}");
-                        Message =
+                    }
-                            $"Error while logging to Splunk Server '{splunkServer.SplunkHecUrl}': {exception.Message}"
+                }
-                    });
+                catch (Exception ex)
-            }
+                {
-        }
+                    LogError($"Error logging to Splunk '{splunkServer.SplunkHecUrl}': {ex.Message}", ex);
+                }
+            }) ?? new List<Task>();
+
+        await Task.WhenAll(tasks);
     }
 
-    public static async Task SendToSplunkServersAsync(LoggerSettings settings, string logType, string message,
+    /// <summary>
-        bool sendToSplunkServer)
+    /// Overload for sending a simple log message to Splunk.
+    /// </summary>
+    public static async Task SendToSplunkServersAsync(LoggerSettings settings, string logType, string message, bool sendToSplunkServer)
     {
         if (settings == null || !sendToSplunkServer || string.IsNullOrWhiteSpace(message))
         {
@@ -214,86 +191,169 @@ internal static class LogHelper
         await SendToSplunkServersAsync(settings, splunkPayload, sendToSplunkServer);
     }
 
+    /// <summary>
+    /// Logs an error using the OnException event.
+    /// </summary>
+    private static void LogError(string message, Exception ex = null)
+    {
+        OnException?.Invoke(null, new ErrorMessage { Message = message, Exception = ex });
+    }
+
+
     internal static async Task SendToGrayLogServersAsync(LoggerSettings settings, string message, ELogType logLevel,
-        string facility, string source, bool sendToGrayLogServer, string version = "1.1")
+    string facility, string source, bool sendToGrayLogServer, string version = "1.1")
     {
         if (settings == null || !sendToGrayLogServer || string.IsNullOrWhiteSpace(message))
         {
             return;
         }
 
-        foreach (var grayLogServer in settings.GrayLogServers ?? new List<GrayLogServer> { new("127.0.0.1") })
+        const int MaxUdpPacketSize = 4096;
-        {
-            try
-            {
-                var gelfMessage = new
-                {
-                    version,
-                    host = Environment.MachineName,
-                    short_message = message,
-                    level = logLevel.ToGrayLogLevel(),
-                    facility,
-                    source,
-                    timestamp = DateTime.UtcNow.ToUnixTimestamp()
-                };
 
-                var messageBytes = Encoding.UTF8.GetBytes(JsonHelper.ToJson(gelfMessage));
+        var gelfMessage = new
-                await grayLogServer.Udp.SendAsync(messageBytes, messageBytes.Length);
+        {
-            }
+            version,
-            catch (Exception exception)
+            host = MachineName,
+            short_message = message,
+            level = logLevel.ToGrayLogLevel(),
+            facility,
+            source,
+            timestamp = DateTime.UtcNow.ToUnixTimestamp()
+        };
+
+        var messageBytes = Encoding.UTF8.GetBytes(JsonHelper.ToJson(gelfMessage));
+
+        var tasks = settings.GrayLogServers?
+            .Where(server => !string.IsNullOrWhiteSpace(server.Hostname) && server.Port >= 0)
+            .Select(async grayLogServer =>
             {
-                OnException?.Invoke(null,
+                try
-                    new ErrorMessage
+                {
+                    if (messageBytes.Length <= MaxUdpPacketSize)
                     {
-                        Exception = exception,
+                        // Send via UDP (single packet)
-                        Message =
+                        await grayLogServer.Udp.SendAsync(messageBytes, messageBytes.Length);
-                            $"Error while logging to GrayLog Server '{grayLogServer.Hostname}': {exception.Message}"
+                    }
+                    else if (grayLogServer.SupportsTcp)
+                    {
+                        // Send via TCP if supported
+                        await SendViaTcpAsync(grayLogServer, messageBytes);
+                    }
+                    else
+                    {
+                        // Chunk large messages for UDP
+                        await SendUdpInChunksAsync(grayLogServer, messageBytes, MaxUdpPacketSize);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnException?.Invoke(null, new ErrorMessage
+                    {
+                        Exception = ex,
+                        Message = $"Error logging to GrayLog Server '{grayLogServer.Hostname}': {ex.Message}"
                     });
-            }
+                }
+            }) ?? new List<Task>();
+
+        await Task.WhenAll(tasks);
+    }
+
+
+    /// <summary>
+    /// Sends a message via TCP to a GrayLog server.
+    /// </summary>
+    private static async Task SendViaTcpAsync(GrayLogServer server, byte[] data)
+    {
+        using var tcpClient = new TcpClient();
+        await tcpClient.ConnectAsync(server.Hostname, server.Port);
+        using var stream = tcpClient.GetStream();
+        await stream.WriteAsync(data, 0, data.Length);
+        await stream.FlushAsync();
+    }
+
+    /// <summary>
+    /// Sends large messages in chunks over UDP.
+    /// </summary>
+    private static async Task SendUdpInChunksAsync(GrayLogServer server, byte[] data, int chunkSize)
+    {
+        for (int i = 0; i < data.Length; i += chunkSize)
+        {
+            var chunk = data.Skip(i).Take(chunkSize).ToArray();
+            await server.Udp.SendAsync(chunk, chunk.Length);
         }
     }
 
-    internal static async Task SendToSysLogServersAsync(LoggerSettings settings, string message,
+    internal static async Task SendToSysLogServersAsync(LoggerSettings settings, string message, bool sendToSyslogServers)
-        bool sendToSyslogServers)
     {
         if (settings == null || !sendToSyslogServers || string.IsNullOrWhiteSpace(message))
         {
             return;
         }
 
-        foreach (var server in settings.SysLogServers ?? new List<SyslogServer> { new("127.0.0.1") })
+        const int MaxUdpPacketSize = 4096;
-        {
-            try
-            {
-                if (string.IsNullOrWhiteSpace(server.Hostname))
-                {
-                    OnException?.Invoke(null,
-                        new ErrorMessage { Message = "Server hostname not specified, skipping SysLog Server" });
-                    continue;
-                }
 
-                if (server.Port < 0)
+        var tasks = settings.SysLogServers?
-                {
+            .Where(server => !string.IsNullOrWhiteSpace(server.Hostname) && server.Port >= 0)
-                    OnException?.Invoke(null,
+            .Select(async server =>
-                        new ErrorMessage { Message = "Server port must be zero or greater, skipping SysLog Server" });
-                    continue;
-                }
-
-                var data = Encoding.UTF8.GetBytes(message);
-                await server.Udp.SendAsync(data, data.Length);
-            }
-            catch (Exception exception)
             {
-                OnException?.Invoke(null,
+                try
-                    new ErrorMessage
+                {
+                    var data = Encoding.UTF8.GetBytes(message);
+
+                    if (data.Length <= MaxUdpPacketSize)
                     {
-                        Exception = exception,
+                        // Send via UDP (single packet)
-                        Message = $"Error while logging to SysLog Server '{server.Hostname}': {exception.Message}"
+                        await server.Udp.SendAsync(data, data.Length);
+                    }
+                    else if (server.SupportsTcp)
+                    {
+                        // Send via TCP if supported
+                        await SendViaTcpAsync(server, data);
+                    }
+                    else
+                    {
+                        // Chunk large messages for UDP
+                        await SendUdpInChunksAsync(server, data, MaxUdpPacketSize);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    OnException?.Invoke(null, new ErrorMessage
+                    {
+                        Exception = ex,
+                        Message = $"Error logging to SysLog Server '{server.Hostname}': {ex.Message}"
                     });
-            }
+                }
+            }) ?? new List<Task>();
+
+        await Task.WhenAll(tasks);
+    }
+
+    /// <summary>
+    /// Sends a message via TCP to a syslog server.
+    /// </summary>
+    private static async Task SendViaTcpAsync(SyslogServer server, byte[] data)
+    {
+        using var tcpClient = new TcpClient();
+        await tcpClient.ConnectAsync(server.Hostname, server.Port);
+        using var stream = tcpClient.GetStream();
+        await stream.WriteAsync(data, 0, data.Length);
+        await stream.FlushAsync();
+    }
+
+    /// <summary>
+    /// Sends large messages in chunks over UDP.
+    /// </summary>
+    private static async Task SendUdpInChunksAsync(SyslogServer server, byte[] data, int chunkSize)
+    {
+        for (int i = 0; i < data.Length; i += chunkSize)
+        {
+            var chunk = data.Skip(i).Take(chunkSize).ToArray();
+            await server.Udp.SendAsync(chunk, chunk.Length);
         }
     }
 
+
     internal static string GetStartupMessage()
     {
         return $"{DllInfo.ApplicationName} started.";

EonaCat.Logger/Managers/LogManager.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -57,6 +56,12 @@ namespace EonaCat.Logger.Managers
             SetupFileLogger(settings);
             SetupLogManager();
             LogHelper.OnException += LogHelper_OnException;
+            LogHelper.OnLogLevelDisabled += LogHelper_OnLogLevelDisabled;
+        }
+
+        private void LogHelper_OnLogLevelDisabled(object sender, ErrorMessage e)
+        {
+            OnLogLevelDisabled?.Invoke(sender, e);
         }
 
         private DateTime CurrentDateTime => Settings.UseLocalTime ? DateTime.Now : DateTime.UtcNow;
@@ -111,8 +116,16 @@ namespace EonaCat.Logger.Managers
                 customSplunkSourceType, sendToGrayLogServers, grayLogFacility, grayLogSource, grayLogVersion);
         }
 
+        /// <summary>
+        /// Gets fired when an exception occurs during logging
+        /// </summary>
         public event EventHandler<ErrorMessage> OnException;
 
+        /// <summary>
+        /// Gets fired when the log level is disabled and the user tries to log a message
+        /// </summary>
+        public event EventHandler<ErrorMessage> OnLogLevelDisabled;
+
         private static LoggerSettings CreateDefaultSettings()
         {
             var settings = new LoggerSettings
@@ -189,31 +202,25 @@ namespace EonaCat.Logger.Managers
         }
 
         private async Task InternalWriteAsync(DateTime dateTime, string message, ELogType logType = ELogType.INFO,
-            bool? writeToConsole = null, bool? sendToSyslogServers = null, bool? sendToSplunkServers = null,
+    bool? writeToConsole = null, bool? sendToSyslogServers = null, bool? sendToSplunkServers = null,
-            string customSplunkSourceType = null, bool? sendToGrayLogServers = null, string grayLogFacility = null,
+    string customSplunkSourceType = null, bool? sendToGrayLogServers = null, string grayLogFacility = null,
-            string grayLogSource = null, string grayLogVersion = "1.1")
+    string grayLogSource = null, string grayLogVersion = "1.1")
         {
-            if (string.IsNullOrEmpty(message) || logType == ELogType.NONE ||
+            if (string.IsNullOrWhiteSpace(message) || logType == ELogType.NONE || !IsLogLevelEnabled(logType) || _isDisposing)
-                (int)logType > (int)Settings.MaxLogType)
-            {
-                return;
-            }
-
-            if (_isDisposing)
             {
                 return;
             }
 
             if (!IsRunning)
             {
-                await StartNewLogAsync();
+                await StartNewLogAsync().ConfigureAwait(false);
             }
 
             var messageWithHeader = LogHelper.FormatMessageWithHeader(Settings, logType, message, dateTime, _category);
-            var writeToConsoleValue = writeToConsole ?? Settings.EnableConsole;
+            var writeToConsoleValue = writeToConsole.GetValueOrDefault(Settings.EnableConsole);
-            var sendToSyslogServersValue = sendToSyslogServers ?? Settings.SendToSyslogServers;
+            var sendToSyslogServersValue = sendToSyslogServers.GetValueOrDefault(Settings.SendToSyslogServers);
-            var sendToSplunkServersValue = sendToSplunkServers ?? Settings.SendToSplunkServers;
+            var sendToSplunkServersValue = sendToSplunkServers.GetValueOrDefault(Settings.SendToSplunkServers);
-            var sendToGrayLogServersValue = sendToGrayLogServers ?? Settings.SendToGrayLogServers;
+            var sendToGrayLogServersValue = sendToGrayLogServers.GetValueOrDefault(Settings.SendToGrayLogServers);
 
             LogHelper.SendToFile(Logger, Settings, logType, message);
 
@@ -222,27 +229,25 @@ namespace EonaCat.Logger.Managers
                 LogHelper.SendToConsole(Settings, logType, messageWithHeader, true);
             }
 
-            var tasks = new List<Task>();
+            var tasks = new List<Task>(3);
-            if (sendToSyslogServersValue || sendToSplunkServersValue || sendToGrayLogServersValue)
+            if (sendToSyslogServersValue)
             {
-                if (sendToSyslogServersValue)
+                tasks.Add(LogHelper.SendToSysLogServersAsync(Settings, messageWithHeader, true));
-                {
+            }
-                    tasks.Add(LogHelper.SendToSysLogServersAsync(Settings, messageWithHeader, true));
+            if (sendToSplunkServersValue)
-                }
+            {
+                tasks.Add(LogHelper.SendToSplunkServersAsync(Settings, customSplunkSourceType ?? logType.ToString(),
+                    messageWithHeader, true));
+            }
+            if (sendToGrayLogServersValue)
+            {
+                tasks.Add(LogHelper.SendToGrayLogServersAsync(Settings, messageWithHeader, logType, grayLogFacility,
+                    grayLogSource, true, grayLogVersion));
+            }
 
-                if (sendToSplunkServersValue)
+            if (tasks.Count > 0)
-                {
+            {
-                    tasks.Add(LogHelper.SendToSplunkServersAsync(Settings, customSplunkSourceType ?? logType.ToString(),
+                await Task.WhenAll(tasks).ConfigureAwait(false);
-                        messageWithHeader, true));
-                }
-
-                if (sendToGrayLogServersValue)
-                {
-                    tasks.Add(LogHelper.SendToGrayLogServersAsync(Settings, messageWithHeader, logType, grayLogFacility,
-                        grayLogSource, true, grayLogVersion));
-                }
-
-                await Task.WhenAll(tasks);
             }
 
             var logMessage = new EonaCatLogMessage
@@ -250,12 +255,27 @@ namespace EonaCat.Logger.Managers
                 DateTime = dateTime,
                 Message = message,
                 LogType = logType,
-                Origin = string.IsNullOrWhiteSpace(Settings.LogOrigin) ? "LogManager" : Settings.LogOrigin
+                Origin = string.IsNullOrEmpty(Settings.LogOrigin) ? "LogManager" : Settings.LogOrigin
             };
-
             Settings.OnLogEvent(logMessage);
         }
 
+        private bool IsLogLevelEnabled(ELogType logType)
+        {
+            if (Settings == null)
+            {
+                OnLogLevelDisabled?.Invoke(this, new ErrorMessage { Message = "Settings is null." });
+                return false;
+            }
+
+            var isEnabled = Settings.MaxLogType != ELogType.NONE && logType <= Settings.MaxLogType;
+            if (!isEnabled)
+            {
+                OnLogLevelDisabled?.Invoke(this, new ErrorMessage { Message = $"Logtype '{logType}' is not enabled, cannot log message" });
+            }
+            return isEnabled;
+        }
+
         public void Reset()
         {
             Settings.ResetLogEvent();

EonaCat.Logger/Syslog/SyslogServer.cs

@@ -77,6 +77,8 @@ public class SyslogServer
     /// </summary>
     public string IpPort => _Hostname + ":" + _Port;
 
+    public bool SupportsTcp { get; set; }
+
     private void SetUdp()
     {
         Udp = null;

README.md

@@ -95,6 +95,7 @@ namespace EonaCat.Logger.Advanced
             // Create and configure a LogManager for logging.
             _logManager = new LogManager(new LoggerSettings { RemoveMessagePrefix = true });
             _logManager.OnException += _logManager_OnException;
+            _logManager.OnLogLevelDisabled += _logManager_OnLogLevelDisabled;
             _logManager.Settings.FileLoggerOptions.FileNamePrefix = "advanced";
             _logManager.Settings.UseLocalTime = true;
             _logManager.Settings.FileLoggerOptions.UseLocalTime = true;
@@ -106,6 +107,16 @@ namespace EonaCat.Logger.Advanced
 
         // Event handler for LogManager exceptions, writes messages to the console.
         private static void _logManager_OnException(object? sender, ErrorMessage e)
+        {
+            Console.WriteLine(e.Message);
+            if (e.Exception != null)
+            {
+                Console.WriteLine(e.Exception);
+            }
+        }
+
+         // Event handler for LogManager loglevel disabled notifications, writes messages to the console.
+        private static void _logManager_OnLogLevelDisabled(object? sender, ErrorMessage e)
         {
             Console.WriteLine(e.Message);
             if (e.Exception != null)