Updated

EonaCat.Logger/EonaCat.Logger.csproj

@@ -2,9 +2,7 @@
   <PropertyGroup>
     <TargetFrameworks>.netstandard2.1; net8.0; net4.8;</TargetFrameworks>
     <ApplicationIcon>icon.ico</ApplicationIcon>
-    <Version>1.5.0</Version>
 	<LangVersion>latest</LangVersion>
-    <FileVersion>1.5.0</FileVersion>
     <Authors>EonaCat (Jeroen Saey)</Authors>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <Company>EonaCat (Jeroen Saey)</Company>
@@ -25,7 +23,7 @@
   </PropertyGroup>
 
 	<PropertyGroup>
-		<EVRevisionFormat>1.5.0+{chash:10}.{c:ymd}</EVRevisionFormat>
+		<EVRevisionFormat>1.5.2+{chash:10}.{c:ymd}</EVRevisionFormat>
 		<EVDefault>true</EVDefault>
 		<EVInfo>true</EVInfo>
 		<EVTagMatch>v[0-9]*</EVTagMatch>
@@ -35,6 +33,17 @@
 		<EVShowRevision>true</EVShowRevision>
 	</PropertyGroup>
 
+    <PropertyGroup>
+      <Version>$(GeneratedVersion)</Version>
+    </PropertyGroup>
+
+    <Target Name="EVPack" BeforeTargets="Pack">
+      <Message Text="EVPack: Forcing NuGet Version = $(GeneratedVersion)" Importance="High"/>
+      <PropertyGroup>
+        <Version>$(GeneratedVersion)</Version>
+      </PropertyGroup>
+    </Target>
+
 	<ItemGroup>
     <None Remove="icon.png" />
     <None Include="..\LICENSE">

EonaCat.Logger/EonaCatCoreLogger/DatabaseLogger.cs

@@ -48,7 +48,9 @@ namespace EonaCat.Logger.EonaCatCoreLogger
             Exception exception, Func<TState, Exception, string> formatter)
         {
             if (!IsEnabled(logLevel) || formatter == null)
+            {
                 return;
+            }
 
             if (IncludeCorrelationId)
             {
@@ -88,7 +90,9 @@ namespace EonaCat.Logger.EonaCatCoreLogger
         private async Task FlushBufferAsync()
         {
             if (!await _flushLock.WaitAsync(0))
+            {
                 return; // Another flush is in progress
+            }
 
             try
             {
@@ -98,7 +102,9 @@ namespace EonaCat.Logger.EonaCatCoreLogger
                     {
                         using var connection = _options.DbProviderFactory.CreateConnection();
                         if (connection == null)
+                        {
                             throw new InvalidOperationException("Failed to create database connection.");
+                        }
 
                         connection.ConnectionString = _options.ConnectionString;
                         await connection.OpenAsync();

EonaCat.Logger/EonaCatCoreLogger/DiscordLogger.cs

@@ -52,7 +52,9 @@ namespace EonaCat.Logger.EonaCatCoreLogger
             Exception exception, Func<TState, Exception, string> formatter)
         {
             if (!IsEnabled(logLevel) || formatter == null)
+            {
                 return;
+            }
 
             if (IncludeCorrelationId)
             {
@@ -98,7 +100,9 @@ namespace EonaCat.Logger.EonaCatCoreLogger
         private async Task FlushBufferAsync()
         {
             if (!await _flushLock.WaitAsync(0))
+            {
                 return; // Already flushing
+            }
 
             try
             {

EonaCat.Logger/EonaCatCoreLogger/TcpLogger.cs

@@ -41,7 +41,10 @@ namespace EonaCat.Logger.EonaCatCoreLogger
         public void Log<TState>(LogLevel logLevel, EventId eventId, TState state,
             Exception exception, Func<TState, Exception, string> formatter)
         {
-            if (!IsEnabled(logLevel)) return;
+            if (!IsEnabled(logLevel))
+            {
+                return;
+            }
 
             try
             {

EonaCat.Logger/EonaCatCoreLogger/XmlFileLogger.cs

@@ -48,7 +48,9 @@ namespace EonaCat.Logger.EonaCatCoreLogger
             Exception exception, Func<TState, Exception, string> formatter)
         {
             if (!IsEnabled(logLevel) || formatter == null)
+            {
                 return;
+            }
 
             try
             {

EonaCat.Logger/Managers/LogManager.cs

@@ -19,81 +19,63 @@ using Microsoft.Extensions.Logging;
 
 namespace EonaCat.Logger.Managers
 {
-    // This file is part of the EonaCat project(s) which is released under the Apache License.
-    // See the LICENSE file or go to https://EonaCat.com/License for full license details.
-
     public class LogManager : ILogManager, IDisposable
     {
         private static readonly Lazy<LogManager> _instance = new(() => new LogManager(CreateDefaultSettings()));
-        private readonly CancellationTokenSource _tokenSource = new();
+        private CancellationTokenSource _tokenSource = new();
         private DateTime _logDate;
         private bool _isDisposing;
         private string _category;
 
         public LogManager(LoggerSettings settings)
         {
-            Settings = settings;
+            Settings = settings ?? CreateDefaultSettings();
             SetupLogManager();
         }
 
-        public LogManager(LoggerSettings settings, string category = null)
+        public LogManager(LoggerSettings settings, string category = null) : this(settings)
         {
-            _category = category;
+            _category = string.IsNullOrWhiteSpace(category) ? "General" : category;
-            if (string.IsNullOrWhiteSpace(category))
-            {
-                _category = "General";
-            }
-            Settings = settings;
             SetupFileLogger(settings);
-            SetupLogManager();
+
+            // Subscribe to static events
             LogHelper.OnException += LogHelper_OnException;
             LogHelper.OnLogLevelDisabled += LogHelper_OnLogLevelDisabled;
         }
 
-        private void LogHelper_OnLogLevelDisabled(object sender, ErrorMessage e)
+        public static LogManager Instance => _instance.Value;
-        {
-            OnLogLevelDisabled?.Invoke(sender, e);
-        }
 
-        private DateTime CurrentDateTime => Settings.UseLocalTime ? DateTime.Now : DateTime.UtcNow;
+        public LoggerSettings Settings { get; private set; }
         public ILoggerProvider LoggerProvider { get; private set; }
         public ILoggerFactory LoggerFactory { get; private set; }
         public ILogger Logger { get; private set; }
+        public bool IsRunning { get; private set; }
 
         public string CurrentLogFile => LoggerProvider is FileLoggerProvider fileLoggerProvider
             ? fileLoggerProvider.LogFile
             : string.Empty;
 
-        public bool IsRunning { get; private set; }
+        private DateTime CurrentDateTime => Settings.UseLocalTime ? DateTime.Now : DateTime.UtcNow;
-
-        public static LogManager Instance => _instance.Value;
-
-        public LoggerSettings Settings { get; set; } = CreateDefaultSettings();
-
-        public void Dispose()
-        {
-            DisposeAsync(true).GetAwaiter().GetResult();
-            GC.SuppressFinalize(this);
-        }
 
+        public event EventHandler<ErrorMessage> OnException;
+        public event EventHandler<ErrorMessage> OnLogLevelDisabled;
         public async Task WriteAsync(object currentObject, ELogType logType = ELogType.INFO, bool? writeToConsole = null,
-            string customSplunkSourceType = null,
+            string customSplunkSourceType = null, string grayLogFacility = null,
-            string grayLogFacility = null, string grayLogSource = null,
+            string grayLogSource = null, string grayLogVersion = "1.1", bool disableSplunkSSL = false,
-            string grayLogVersion = "1.1", bool disableSplunkSSL = false, DumpFormat dumpFormat = DumpFormat.Json, bool isDetailedDump = false, int? dumpDepth = null, int? maxCollectionItems = null)
+            DumpFormat dumpFormat = DumpFormat.Json, bool isDetailedDump = false, int? dumpDepth = null, int? maxCollectionItems = null)
         {
             if (currentObject == null)
             {
                 return;
             }
 
-            await WriteAsync(currentObject.Dump(dumpFormat, isDetailedDump, dumpDepth, maxCollectionItems), logType, writeToConsole, 
+            await WriteAsync(currentObject.Dump(dumpFormat, isDetailedDump, dumpDepth, maxCollectionItems),
-                customSplunkSourceType, grayLogFacility, grayLogSource,
+                logType, writeToConsole, customSplunkSourceType, grayLogFacility, grayLogSource, grayLogVersion, disableSplunkSSL);
-                grayLogVersion, disableSplunkSSL);
         }
 
         public async Task WriteAsync(Exception exception, string module = null, string method = null,
-            bool criticalException = false,
+            bool criticalException = false, bool? writeToConsole = null,
-            bool? writeToConsole = null, string customSplunkSourceType = null, string grayLogFacility = null,
+            string customSplunkSourceType = null, string grayLogFacility = null,
             string grayLogSource = null, string grayLogVersion = "1.1", bool disableSplunkSSL = false)
         {
             if (exception == null)
@@ -102,14 +84,12 @@ namespace EonaCat.Logger.Managers
             }
 
             await WriteAsync(exception.FormatExceptionToMessage(module, method),
-                criticalException ? ELogType.CRITICAL : ELogType.ERROR, writeToConsole, 
+                criticalException ? ELogType.CRITICAL : ELogType.ERROR,
-                customSplunkSourceType, grayLogFacility, grayLogSource,
+                writeToConsole, customSplunkSourceType, grayLogFacility, grayLogSource, grayLogVersion, disableSplunkSSL);
-                grayLogVersion, disableSplunkSSL = false);
         }
 
         public async Task WriteAsync(string message, ELogType logType = ELogType.INFO, bool? writeToConsole = null,
-            string customSplunkSourceType = null,
+            string customSplunkSourceType = null, string grayLogFacility = null, string grayLogSource = null,
-            string grayLogFacility = null, string grayLogSource = null,
             string grayLogVersion = "1.1", bool disableSplunkSSL = false)
         {
             if (logType == ELogType.NONE)
@@ -121,35 +101,6 @@ namespace EonaCat.Logger.Managers
                 customSplunkSourceType, grayLogFacility, grayLogSource, grayLogVersion, disableSplunkSSL);
         }
 
-        /// <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
-            {
-                Id = DllInfo.ApplicationName,
-            };
-            return settings;
-        }
-
-        protected virtual async Task DisposeAsync(bool disposing)
-        {
-            if (disposing)
-            {
-                _isDisposing = true;
-                await StopLoggingAsync();
-                await Task.Delay(100);
-            }
-        }
-
         public async Task StartNewLogAsync()
         {
             if (_tokenSource.IsCancellationRequested)
@@ -163,57 +114,73 @@ namespace EonaCat.Logger.Managers
             }
 
             IsRunning = true;
-
             CreateLogger();
-
             Directory.CreateDirectory(Settings.FileLoggerOptions.LogDirectory);
-
             _logDate = CurrentDateTime;
         }
 
+        private async Task StopLoggingAsync()
+        {
+            WriteStopMessage();
+            IsRunning = false;
+            await Task.CompletedTask;
+        }
+
+        private void WriteStopMessage()
+        {
+            var stopMessage = $"{DllInfo.ApplicationName} stopped.{Environment.NewLine}";
+            LogHelper.SendToFile(Logger, Settings, ELogType.INFO, stopMessage);
+        }
+
         private void CreateLogger()
         {
-            // Dispose of previous ServiceProvider if it exists
+            // Dispose previous providers safely
             LoggerProvider?.Dispose();
             LoggerFactory?.Dispose();
 
             IServiceCollection serviceCollection = new ServiceCollection();
 
-            if (Settings.TypesToLog == null)
+            if (Settings.TypesToLog == null || !Settings.TypesToLog.Any())
             {
-                Settings.TypesToLog = new List<ELogType> { ELogType.INFO, ELogType.WARNING, ELogType.ERROR, ELogType.TRAFFIC, ELogType.DEBUG, ELogType.CRITICAL, ELogType.TRACE };
+                Settings.TypesToLog = new List<ELogType>
+                {
+                    ELogType.INFO, ELogType.WARNING, ELogType.ERROR,
+                    ELogType.TRAFFIC, ELogType.DEBUG, ELogType.CRITICAL, ELogType.TRACE
+                };
             }
 
-            serviceCollection.AddLogging(builder => builder.SetMinimumLevel(Settings.TypesToLog.Max().ToLogLevel())
+            serviceCollection.AddLogging(builder =>
-                .AddEonaCatFileLogger(configuration =>
+                builder.SetMinimumLevel(Settings.TypesToLog.Max().ToLogLevel())
-                {
+                       .AddEonaCatFileLogger(config =>
-                    var fileLoggerOptions = Settings.FileLoggerOptions;
+                       {
-                    configuration.MaxWriteTries = fileLoggerOptions.MaxWriteTries;
+                           var options = Settings.FileLoggerOptions;
-                    configuration.RetainedFileCountLimit = fileLoggerOptions.RetainedFileCountLimit;
+                           config.MaxWriteTries = options.MaxWriteTries;
-                    configuration.FlushPeriod = fileLoggerOptions.FlushPeriod;
+                           config.RetainedFileCountLimit = options.RetainedFileCountLimit;
-                    configuration.IsEnabled = fileLoggerOptions.IsEnabled;
+                           config.FlushPeriod = options.FlushPeriod;
-                    configuration.BatchSize = fileLoggerOptions.BatchSize;
+                           config.IsEnabled = options.IsEnabled;
-                    configuration.FileSizeLimit = fileLoggerOptions.FileSizeLimit;
+                           config.BatchSize = options.BatchSize;
-                    configuration.LogDirectory = fileLoggerOptions.LogDirectory;
+                           config.FileSizeLimit = options.FileSizeLimit;
-                    configuration.FileNamePrefix = fileLoggerOptions.FileNamePrefix;
+                           config.LogDirectory = options.LogDirectory;
-                    configuration.MaxRolloverFiles = fileLoggerOptions.MaxRolloverFiles;
+                           config.FileNamePrefix = options.FileNamePrefix;
-                    configuration.UseLocalTime = Settings.UseLocalTime;
+                           config.MaxRolloverFiles = options.MaxRolloverFiles;
-                    configuration.UseMask = Settings.UseMask;
+                           config.UseLocalTime = Settings.UseLocalTime;
-                    configuration.Mask = fileLoggerOptions.Mask;
+                           config.UseMask = Settings.UseMask;
-                    configuration.UseDefaultMasking = Settings.UseDefaultMasking;
+                           config.Mask = options.Mask;
-                    configuration.MaskedKeywords = fileLoggerOptions.MaskedKeywords;
+                           config.UseDefaultMasking = Settings.UseDefaultMasking;
-                }));
+                           config.MaskedKeywords = options.MaskedKeywords;
+                       }));
 
             var serviceProvider = serviceCollection.BuildServiceProvider();
             LoggerProvider = serviceProvider.GetService<ILoggerProvider>();
             LoggerFactory = serviceProvider.GetService<ILoggerFactory>();
             Logger = LoggerFactory.CreateLogger(Settings.Id);
+
             LogHelper.SendToFile(Logger, Settings, ELogType.INFO, LogHelper.GetStartupMessage());
         }
 
         private async Task InternalWriteAsync(DateTime dateTime, string message, ELogType logType = ELogType.INFO,
-    bool? writeToConsole = null, string customSplunkSourceType = null, string grayLogFacility = null,
+            bool? writeToConsole = null, string customSplunkSourceType = null, string grayLogFacility = null,
-    string grayLogSource = null, string grayLogVersion = "1.1", bool disableSplunkSSL = false)
+            string grayLogSource = null, string grayLogVersion = "1.1", bool disableSplunkSSL = false)
         {
             if (string.IsNullOrWhiteSpace(message) || logType == ELogType.NONE || !IsLogLevelEnabled(logType) || _isDisposing)
             {
@@ -235,29 +202,32 @@ namespace EonaCat.Logger.Managers
                 LogHelper.SendToConsole(Settings, logType, messageWithHeader);
             }
 
-            var tasks = new List<Task>(5)
+            var tasks = new List<Task>
             {
                 LogHelper.SendToSysLogServersAsync(Settings, message, logType, dateTime, _category),
                 LogHelper.SendToSplunkServersAsync(Settings, customSplunkSourceType ?? logType.ToString(), messageWithHeader, disableSplunkSSL),
                 LogHelper.SendToGrayLogServersAsync(Settings, messageWithHeader, logType, grayLogFacility, grayLogSource, grayLogVersion),
                 LogHelper.SendToTcpLogServersAsync(Settings, messageWithHeader, logType),
-                LogHelper.SendToUdpLogServersAsync(Settings, messageWithHeader, logType),
+                LogHelper.SendToUdpLogServersAsync(Settings, messageWithHeader, logType)
             };
 
-            if (tasks.Count > 0)
+            try
             {
                 await Task.WhenAll(tasks).ConfigureAwait(false);
             }
+            catch (Exception ex)
+            {
+                OnException?.Invoke(this, new ErrorMessage { Message = ex.Message, Exception = ex });
+            }
 
-            var logMessage = new EonaCatLogMessage
+            Settings.OnLogEvent(new EonaCatLogMessage
             {
                 DateTime = dateTime,
                 Message = message,
                 LogType = logType,
                 Origin = string.IsNullOrEmpty(Settings.LogOrigin) ? "LogManager" : Settings.LogOrigin,
-                Category = _category,
+                Category = _category
-            };
+            });
-            Settings.OnLogEvent(logMessage);
         }
 
         private bool IsLogLevelEnabled(ELogType logType)
@@ -268,42 +238,74 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            if (logType == ELogType.NONE)
+            return logType != ELogType.NONE &&
+                   (Settings.TypesToLog == null || !Settings.TypesToLog.Any() || Settings.TypesToLog.Contains(logType));
+        }
+
+        private void LogHelper_OnException(object sender, ErrorMessage e) => OnException?.Invoke(sender, e);
+        private void LogHelper_OnLogLevelDisabled(object sender, ErrorMessage e) => OnLogLevelDisabled?.Invoke(sender, e);
+        public void Dispose()
+        {
+            DisposeAsync(true).GetAwaiter().GetResult();
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual async Task DisposeAsync(bool disposing)
+        {
+            if (_isDisposing)
             {
-                return false;
+                return;
             }
 
-            var isEnabled = (Settings.TypesToLog == null || Settings.TypesToLog.Count == 0 || Settings.TypesToLog.Contains(logType));
+            if (disposing)
-            if (!isEnabled)
             {
-                return false;
+                _isDisposing = true;
+
+                await StopLoggingAsync();
+
+                // Unsubscribe events
+                LogHelper.OnException -= LogHelper_OnException;
+                LogHelper.OnLogLevelDisabled -= LogHelper_OnLogLevelDisabled;
+
+                // Cancel token
+                _tokenSource.Cancel();
+                _tokenSource.Dispose();
+                _tokenSource = null;
+
+                LoggerProvider?.Dispose();
+                LoggerFactory?.Dispose();
+
+                await Task.Delay(50);
             }
-            return true;
         }
 
-        public void Reset()
+        public static void Shutdown()
         {
-            Settings.ResetLogEvent();
+            if (_instance.IsValueCreated)
+            {
+                _instance.Value.Dispose();
+            }
+        }
+        public void DeleteCurrentLogFile()
+        {
+            if (!string.IsNullOrEmpty(CurrentLogFile) && File.Exists(CurrentLogFile))
+            {
+                File.Delete(CurrentLogFile);
+            }
         }
 
-        private void LogHelper_OnException(object sender, ErrorMessage e)
+        private static LoggerSettings CreateDefaultSettings() => new() { Id = DllInfo.ApplicationName };
-        {
-            OnException?.Invoke(sender, e);
-        }
 
         private void SetupFileLogger(LoggerSettings settings = null, string logFolder = null, bool defaultPrefix = true)
         {
-            if (settings == null)
+            settings ??= Settings;
-            {
-                settings = Settings;
-            }
 
             if (!settings.EnableFileLogging)
             {
                 return;
             }
 
-            if (logFolder != null)
+            if (!string.IsNullOrWhiteSpace(logFolder))
             {
                 settings.FileLoggerOptions.LogDirectory = logFolder;
             }
@@ -314,50 +316,14 @@ namespace EonaCat.Logger.Managers
             }
         }
 
-        private void SetupLogManager()
+        private void SetupLogManager() => _logDate = CurrentDateTime;
-        {
-            _logDate = CurrentDateTime;
-        }
 
-        private Task StopLoggingAsync()
+        // Syslog
-        {
-            WriteStopMessage();
-            IsRunning = false;
-            return Task.CompletedTask;
-        }
-
-        private void WriteStopMessage()
-        {
-            var stopMessage = $"{DllInfo.ApplicationName} stopped.{Environment.NewLine}";
-            LogHelper.SendToFile(Logger, Settings, ELogType.INFO, stopMessage);
-        }
-
-        public void DeleteCurrentLogFile()
-        {
-            if (!string.IsNullOrEmpty(CurrentLogFile))
-            {
-                File.Delete(CurrentLogFile);
-            }
-        }
-
-        /// <summary>
-        /// Add Syslog server
-        /// </summary>
-        /// <param name="address"></param>
-        /// <param name="port"></param>
-        /// <param name="nickName"></param>
-        /// <param name="typesToLog"></param>
-        /// <param name="convertToRfc5424"></param>
-        /// <param name="convertToRfc3164"></param>
-        /// <returns></returns>
         public bool AddSyslogServer(string address, int port, string nickName = null, List<ELogType> typesToLog = null, bool convertToRfc5424 = false, bool convertToRfc3164 = false)
         {
-            if (Settings.SysLogServers == null)
+            Settings.SysLogServers ??= new List<Syslog>();
-            {
-                Settings.SysLogServers = new List<Servers.Syslog.Syslog>();
-            }
 
-            if (Settings.SysLogServers.Any(x => (nickName != null && x.Nickname == nickName) || nickName == null && x.Hostname == address && x.Port == port))
+            if (Settings.SysLogServers.Any(x => (nickName != null && x.Nickname == nickName) || (nickName == null && x.Hostname == address && x.Port == port)))
             {
                 return false;
             }
@@ -366,12 +332,6 @@ namespace EonaCat.Logger.Managers
             return true;
         }
 
-        /// <summary>
-        /// Remove the sysLog server
-        /// </summary>
-        /// <param name="address"></param>
-        /// <param name="port"></param>
-        /// <returns></returns>
         public bool RemoveSyslogServer(string address, int port)
         {
             if (Settings.SysLogServers == null)
@@ -379,19 +339,15 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.SysLogServers.FirstOrDefault(x => x.Hostname == address && x.Port == port);
+            var server = Settings.SysLogServers.FirstOrDefault(x => x.Hostname == address && x.Port == port);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.SysLogServers.Remove(delete);
+                Settings.SysLogServers.Remove(server);
             }
+
             return true;
         }
 
-        /// <summary>
-        /// Remove the sysLog server
-        /// </summary>
-        /// <param name="nickName"></param>
-        /// <returns></returns>
         public bool RemoveSyslogServer(string nickName)
         {
             if (Settings.SysLogServers == null)
@@ -399,31 +355,21 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.SysLogServers.FirstOrDefault(x => x.Nickname == nickName);
+            var server = Settings.SysLogServers.FirstOrDefault(x => x.Nickname == nickName);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.SysLogServers.Remove(delete);
+                Settings.SysLogServers.Remove(server);
             }
+
             return true;
         }
 
-        /// <summary>
+        // Splunk
-        /// Add Splunk server
-        /// </summary>
-        /// <param name="splunkHecUrl"></param>
-        /// <param name="splunkHecToken"></param>
-        /// <param name="httpClientHandler"></param>
-        /// <param name="nickName"></param>
-        /// <param name="typesToLog"></param>
-        /// <returns></returns>
         public bool AddSplunkServer(string splunkHecUrl, string splunkHecToken, HttpClientHandler httpClientHandler = null, string nickName = null, List<ELogType> typesToLog = null)
         {
-            if (Settings.SplunkServers == null)
+            Settings.SplunkServers ??= new List<Splunk>();
-            {
-                Settings.SplunkServers = new List<Splunk>();
-            }
 
-            if (Settings.SplunkServers.Any(x => (nickName != null && x.Nickname == nickName) || nickName == null && x.SplunkHecUrl == splunkHecUrl && x.SplunkHecToken == splunkHecToken))
+            if (Settings.SplunkServers.Any(x => (nickName != null && x.Nickname == nickName) || (nickName == null && x.SplunkHecUrl == splunkHecUrl && x.SplunkHecToken == splunkHecToken)))
             {
                 return false;
             }
@@ -432,12 +378,6 @@ namespace EonaCat.Logger.Managers
             return true;
         }
 
-        /// <summary>
-        /// Remove the Splunk server
-        /// </summary>
-        /// <param name="splunkHecUrl"></param>
-        /// <param name="splunkHecToken"></param>
-        /// <returns></returns>
         public bool RemoveSplunkServer(string splunkHecUrl, string splunkHecToken)
         {
             if (Settings.SplunkServers == null)
@@ -445,19 +385,15 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.SplunkServers.FirstOrDefault(x => x.SplunkHecUrl == splunkHecUrl && x.SplunkHecToken == splunkHecToken);
+            var server = Settings.SplunkServers.FirstOrDefault(x => x.SplunkHecUrl == splunkHecUrl && x.SplunkHecToken == splunkHecToken);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.SplunkServers.Remove(delete);
+                Settings.SplunkServers.Remove(server);
             }
+
             return true;
         }
 
-        /// <summary>
-        /// Remove the Splunk server
-        /// </summary>
-        /// <param name="nickName"></param>
-        /// <returns></returns>
         public bool RemoveSplunkServer(string nickName)
         {
             if (Settings.SplunkServers == null)
@@ -465,30 +401,21 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.SplunkServers.FirstOrDefault(x => x.Nickname == nickName);
+            var server = Settings.SplunkServers.FirstOrDefault(x => x.Nickname == nickName);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.SplunkServers.Remove(delete);
+                Settings.SplunkServers.Remove(server);
             }
+
             return true;
         }
 
-        /// <summary>
+        // Graylog
-        /// Add Graylog server
-        /// </summary>
-        /// <param name="address"></param>
-        /// <param name="port"></param>
-        /// <param name="nickName"></param>
-        /// <param name="typesToLog"></param>
-        /// <returns></returns>
         public bool AddGrayLogServer(string address, int port, string nickName = null, List<ELogType> typesToLog = null)
         {
-            if (Settings.GrayLogServers == null)
+            Settings.GrayLogServers ??= new List<Graylog>();
-            {
-                Settings.GrayLogServers = new List<Graylog>();
-            }
 
-            if (Settings.GrayLogServers.Any(x => (nickName != null && x.Nickname == nickName) || nickName == null && x.Hostname == address && x.Port == port))
+            if (Settings.GrayLogServers.Any(x => (nickName != null && x.Nickname == nickName) || (nickName == null && x.Hostname == address && x.Port == port)))
             {
                 return false;
             }
@@ -497,12 +424,6 @@ namespace EonaCat.Logger.Managers
             return true;
         }
 
-        /// <summary>
-        /// Remove the GrayLog server
-        /// </summary>
-        /// <param name="address"></param>
-        /// <param name="port"></param>
-        /// <returns></returns>
         public bool RemoveGrayLogServer(string address, int port)
         {
             if (Settings.GrayLogServers == null)
@@ -510,19 +431,15 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.GrayLogServers.FirstOrDefault(x => x.Hostname == address && x.Port == port);
+            var server = Settings.GrayLogServers.FirstOrDefault(x => x.Hostname == address && x.Port == port);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.GrayLogServers.Remove(delete);
+                Settings.GrayLogServers.Remove(server);
             }
+
             return true;
         }
 
-        /// <summary>
-        /// Remove the GrayLog server
-        /// </summary>
-        /// <param name="nickName"></param>
-        /// <returns></returns>
         public bool RemoveGrayLogServer(string nickName)
         {
             if (Settings.GrayLogServers == null)
@@ -530,28 +447,19 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.GrayLogServers.FirstOrDefault(x => x.Nickname == nickName);
+            var server = Settings.GrayLogServers.FirstOrDefault(x => x.Nickname == nickName);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.GrayLogServers.Remove(delete);
+                Settings.GrayLogServers.Remove(server);
             }
+
             return true;
         }
 
-        /// <summary>
+        // TCP
-        /// Add Tcp Server
-        /// </summary>
-        /// <param name="address"></param>
-        /// <param name="port"></param>
-        /// <param name="nickName"></param>
-        /// <param name="typesToLog"></param>
-        /// <returns></returns>
         public bool AddTcpLogServer(string address, int port, string nickName = null, List<ELogType> typesToLog = null)
         {
-            if (Settings.TcpServers == null)
+            Settings.TcpServers ??= new List<Servers.Tcp.Tcp>();
-            {
-                Settings.TcpServers = new List<Servers.Tcp.Tcp>();
-            }
 
             if (Settings.TcpServers.Any(x => (nickName != null && x.Nickname == nickName) || (nickName == null && x.Hostname == address && x.Port == port)))
             {
@@ -562,12 +470,6 @@ namespace EonaCat.Logger.Managers
             return true;
         }
 
-        /// <summary>
-        /// Remove the Tcp server
-        /// </summary>
-        /// <param name="address"></param>
-        /// <param name="port"></param>
-        /// <returns></returns>
         public bool RemoveTcpLogServer(string address, int port)
         {
             if (Settings.TcpServers == null)
@@ -575,19 +477,15 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.TcpServers.FirstOrDefault(x => x.Hostname == address && x.Port == port);
+            var server = Settings.TcpServers.FirstOrDefault(x => x.Hostname == address && x.Port == port);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.TcpServers.Remove(delete);
+                Settings.TcpServers.Remove(server);
             }
+
             return true;
         }
 
-        /// <summary>
-        /// Remove the Tcp server
-        /// </summary>
-        /// <param name="nickName"></param>
-        /// <returns></returns>
         public bool RemoveTcpLogServer(string nickName)
         {
             if (Settings.TcpServers == null)
@@ -595,30 +493,21 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.TcpServers.FirstOrDefault(x => x.Nickname == nickName);
+            var server = Settings.TcpServers.FirstOrDefault(x => x.Nickname == nickName);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.TcpServers.Remove(delete);
+                Settings.TcpServers.Remove(server);
             }
+
             return true;
         }
 
-        /// <summary>
+        // UDP
-        /// Add Udp Server
-        /// </summary>
-        /// <param name="address"></param>
-        /// <param name="port"></param>
-        /// <param name="nickName"></param>
-        /// <param name="typesToLog"></param>
-        /// <returns></returns>
         public bool AddUdpLogServer(string address, int port, string nickName = null, List<ELogType> typesToLog = null)
         {
-            if (Settings.UdpServers == null)
+            Settings.UdpServers ??= new List<Servers.Udp.Udp>();
-            {
-                Settings.UdpServers = new List<Servers.Udp.Udp>();
-            }
 
-            if (Settings.UdpServers.Any(x => (nickName != null && x.Nickname == nickName) || nickName == null && x.Hostname == address && x.Port == port))
+            if (Settings.UdpServers.Any(x => (nickName != null && x.Nickname == nickName) || (nickName == null && x.Hostname == address && x.Port == port)))
             {
                 return false;
             }
@@ -627,12 +516,6 @@ namespace EonaCat.Logger.Managers
             return true;
         }
 
-        /// <summary>
-        /// Remove the Udp server
-        /// </summary>
-        /// <param name="address"></param>
-        /// <param name="port"></param>
-        /// <returns></returns>
         public bool RemoveUdpLogServer(string address, int port)
         {
             if (Settings.UdpServers == null)
@@ -640,19 +523,15 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.UdpServers.FirstOrDefault(x => x.Hostname == address && x.Port == port);
+            var server = Settings.UdpServers.FirstOrDefault(x => x.Hostname == address && x.Port == port);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.UdpServers.Remove(delete);
+                Settings.UdpServers.Remove(server);
             }
+
             return true;
         }
 
-        /// <summary>
-        /// Remove the Udp server
-        /// </summary>
-        /// <param name="nickName"></param>
-        /// <returns></returns>
         public bool RemoveUdpLogServer(string nickName)
         {
             if (Settings.UdpServers == null)
@@ -660,11 +539,12 @@ namespace EonaCat.Logger.Managers
                 return false;
             }
 
-            var delete = Settings.UdpServers.FirstOrDefault(x => x.Nickname == nickName);
+            var server = Settings.UdpServers.FirstOrDefault(x => x.Nickname == nickName);
-            if (delete != null)
+            if (server != null)
             {
-                Settings.UdpServers.Remove(delete);
+                Settings.UdpServers.Remove(server);
             }
+
             return true;
         }
     }

EonaCat.Logger/Servers/Splunk/Splunk.cs

@@ -28,7 +28,9 @@ namespace EonaCat.Logger.Servers.Splunk
             set
             {
                 if (string.IsNullOrWhiteSpace(value))
+                {
                     throw new ArgumentNullException(nameof(SplunkHecUrl));
+                }
 
                 _splunkHecUrl = value.StartsWith("http", StringComparison.OrdinalIgnoreCase)
                     ? value
@@ -91,13 +93,19 @@ namespace EonaCat.Logger.Servers.Splunk
             try
             {
                 if (payload == null)
+                {
                     return null;
+                }
 
                 if (!HasHecToken || !HasHecUrl)
+                {
                     return null;
+                }
 
                 if (disableSplunkSSL)
+                {
                     DisableSSLValidation();
+                }
 
                 _httpClient ??= new HttpClient(_httpClientHandler ?? new HttpClientHandler())
                 {

EonaCat.Logger/Servers/Syslog/Syslog.cs

@@ -42,7 +42,9 @@ namespace EonaCat.Logger.Servers.Syslog
             set
             {
                 if (string.IsNullOrWhiteSpace(value))
+                {
                     throw new ArgumentNullException(nameof(Hostname));
+                }
 
                 _hostname = value;
                 SetUdp();
@@ -55,7 +57,9 @@ namespace EonaCat.Logger.Servers.Syslog
             set
             {
                 if (value < 0)
+                {
                     throw new ArgumentException("Port must be zero or greater.");
+                }
 
                 _port = value;
                 SetUdp();
@@ -96,7 +100,9 @@ namespace EonaCat.Logger.Servers.Syslog
         public async Task WriteAsync(string message)
         {
             if (string.IsNullOrWhiteSpace(message))
+            {
                 return;
+            }
 
             var data = Encoding.UTF8.GetBytes(message);
             await SendAsync(data);
@@ -105,13 +111,17 @@ namespace EonaCat.Logger.Servers.Syslog
         public async Task WriteAsync(byte[] data)
         {
             if (data is { Length: > 0 })
+            {
                 await SendAsync(data);
+            }
         }
 
         private async Task SendAsync(byte[] data)
         {
             if (_udp == null)
+            {
                 return;
+            }
 
             if (data.Length <= MaxUdpPacketSize)
             {

EonaCat.Logger/Servers/Tcp/Tcp.cs

@@ -38,7 +38,9 @@ namespace EonaCat.Logger.Servers.Tcp
             set
             {
                 if (string.IsNullOrWhiteSpace(value))
+                {
                     throw new ArgumentNullException(nameof(Hostname));
+                }
 
                 _hostname = value;
                 SetTcp();
@@ -51,7 +53,9 @@ namespace EonaCat.Logger.Servers.Tcp
             set
             {
                 if (value < 0)
+                {
                     throw new ArgumentException("Port must be zero or greater.");
+                }
 
                 _port = value;
                 SetTcp();
@@ -91,13 +95,21 @@ namespace EonaCat.Logger.Servers.Tcp
 
         public async Task WriteAsync(byte[] data)
         {
-            if (data == null || data.Length == 0) return;
+            if (data == null || data.Length == 0)
+            {
+                return;
+            }
+
             await InternalWriteAsync(data);
         }
 
         public async Task WriteAsync(string data)
         {
-            if (string.IsNullOrWhiteSpace(data)) return;
+            if (string.IsNullOrWhiteSpace(data))
+            {
+                return;
+            }
+
             var bytes = Encoding.UTF8.GetBytes(data);
             await InternalWriteAsync(bytes);
         }
@@ -108,10 +120,14 @@ namespace EonaCat.Logger.Servers.Tcp
             try
             {
                 if (!IsConnected || _tcp == null)
+                {
                     SetTcp();
+                }
 
                 if (!IsConnected || _tcp == null)
+                {
                     return;
+                }
 
                 var stream = _tcp.GetStream();
                 await stream.WriteAsync(data, 0, data.Length);

EonaCat.Logger/Servers/Udp/Udp.cs

@@ -39,7 +39,9 @@ namespace EonaCat.Logger.Servers.Udp
             set
             {
                 if (string.IsNullOrWhiteSpace(value))
+                {
                     throw new ArgumentNullException(nameof(Hostname));
+                }
 
                 _hostname = value;
                 SetUdp();
@@ -52,7 +54,9 @@ namespace EonaCat.Logger.Servers.Udp
             set
             {
                 if (value < 0)
+                {
                     throw new ArgumentException("Port must be zero or greater.");
+                }
 
                 _port = value;
                 SetUdp();
@@ -96,16 +100,22 @@ namespace EonaCat.Logger.Servers.Udp
         public async Task WriteAsync(byte[] data, bool dontFragment = false)
         {
             if (data == null || data.Length == 0)
+            {
                 return;
+            }
 
             await _sendLock.WaitAsync();
             try
             {
                 if (!IsConnected)
+                {
                     SetUdp();
+                }
 
                 if (!IsConnected || _udp == null)
+                {
                     return;
+                }
 
                 _udp.DontFragment = dontFragment;
 
@@ -120,7 +130,9 @@ namespace EonaCat.Logger.Servers.Udp
         public async Task WriteAsync(string data, bool dontFragment = false)
         {
             if (string.IsNullOrWhiteSpace(data))
+            {
                 return;
+            }
 
             var bytes = Encoding.UTF8.GetBytes(data);
             await WriteAsync(bytes, dontFragment);

Testers/EonaCat.Logger.Test.Web/Program.cs

@@ -40,6 +40,17 @@
             int onLogCounter = 0;
             var defaultColor = Console.ForegroundColor;
 
+            _ = Task.Run(() =>
+            {
+                var logman = LogManager.Instance;
+                var i = 0;
+                while (true)
+                {
+                    logman.WriteAsync($"Logman test {++i}", ELogType.TRACE).ConfigureAwait(false);
+                    Task.Delay(10).ConfigureAwait(false);
+                }
+            }).ConfigureAwait(false);
+
             // Add services to the container.
             Logger logger = new Logger();
             logger.UseLocalTime = true;
@@ -209,7 +220,7 @@
                 }
             }
 
-            MemoryLeakTester.Start(logger);
+            //MemoryLeakTester.Start(logger);
             _ = Task.Run(RunMemoryReportTask).ConfigureAwait(false);
             _ = Task.Run(RunMaskTest).ConfigureAwait(false);
             _ = Task.Run(RunWebLoggerTestsAsync).ConfigureAwait(false);