EonaCat/EonaCat.Logger
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Updated

Browse Source
This commit is contained in:
Jeroen Saey
2024-10-14 15:43:29 +02:00
parent 44e4da0a24
commit 8d902100de
3 changed files with 373 additions and 427 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
EonaCat.Logger/EonaCat.Logger.csproj
View File

@@ -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.3</FileVersion>
<FileVersion>1.3.4</FileVersion>
<Authors>EonaCat (Jeroen Saey)</Authors>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<Company>EonaCat (Jeroen Saey)</Company>
@@ -24,7 +24,7 @@
</PropertyGroup>
<PropertyGroup>
<EVRevisionFormat>1.3.3+{chash:10}.{c:ymd}</EVRevisionFormat>
<EVRevisionFormat>1.3.4+{chash:10}.{c:ymd}</EVRevisionFormat>
<EVDefault>true</EVDefault>
<EVInfo>true</EVInfo>
<EVTagMatch>v[0-9]*</EVTagMatch>

153
EonaCat.Logger/Managers/LogHelper.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
@@ -27,89 +28,49 @@ internal static class LogHelper
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))
{
return currentMessage;
}
if (string.IsNullOrWhiteSpace(category))
{
category = "General";
}
if (string.IsNullOrWhiteSpace(currentMessage)) return currentMessage;
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}",
dateTime.ToString(settings?.TimestampFormat ?? "yyyy-MM-dd HH:mm:ss") + " " +
(settings?.UseLocalTime ?? false ? "[LOCAL]" : "[UTC]"))
.Replace("{host}", $"[Host:{Dns.GetHostName()}]")
sb.Replace("{ts}", $"{timestamp} {timeLabel}")
.Replace("{host}", $"[Host:{HostName}]")
.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))
{
return;
}
if (settings == null || !writeToConsole || string.IsNullOrWhiteSpace(message)) return;
if (settings.EnableColors && settings.Colors != null)
{
var prevForeground = Console.ForegroundColor;
var prevBackground = Console.BackgroundColor;
ConsoleColor foregroundColor;
ConsoleColor backgroundColor;
switch (logType)
if (TryGetLogColor(settings.Colors, logType, out var foregroundColor, out var backgroundColor))
{
case ELogType.DEBUG:
foregroundColor = settings.Colors.Debug.Foreground;
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.ForegroundColor = foregroundColor;
Console.BackgroundColor = backgroundColor;
Console.WriteLine(message);
Console.ForegroundColor = prevForeground;
Console.BackgroundColor = prevBackground;
@@ -120,21 +81,40 @@ 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 ||
string.IsNullOrWhiteSpace(message))
{
return;
}
foreground = default;
background = default;
var logLevel = logType.ToLogLevel();
if (IsLogLevelEnabled(settings, logType))
return logType switch
{
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 TrySetColors(ColorScheme color, out ConsoleColor foreground, out ConsoleColor background)
{
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)
@@ -146,8 +126,9 @@ internal static class LogHelper
var isEnabled = loggerSettings.MaxLogType != ELogType.NONE && logType <= loggerSettings.MaxLogType;
if (!isEnabled)
{
OnLogLevelDisabled?.Invoke(null, new ErrorMessage { Message = $"Logtype '{logType}' is not enabled, cannot log message" });
OnLogLevelDisabled?.Invoke(null, new ErrorMessage { Message = $"Logtype '{logType}' is not enabled." });
}
return isEnabled;
}
@@ -161,55 +142,29 @@ internal static class LogHelper
logger.Log(logLevel, message);
}
public static async Task SendToSplunkServersAsync(LoggerSettings settings, SplunkPayload splunkPayload,
bool sendToSplunkServer)
public static async Task SendToSplunkServersAsync(LoggerSettings settings, SplunkPayload splunkPayload, bool sendToSplunkServer)
{
if (settings == null || !sendToSplunkServer || splunkPayload == null)
{
return;
}
if (settings == null || !sendToSplunkServer || splunkPayload == null) return;
if (settings.SplunkServers == null)
{
settings.SplunkServers = new List<SplunkServer.SplunkServer>();
}
foreach (var splunkServer in settings.SplunkServers)
foreach (var splunkServer in settings.SplunkServers ?? Enumerable.Empty<SplunkServer.SplunkServer>())
{
if (!splunkServer.HasHecUrl || !splunkServer.HasHecToken)
{
OnException?.Invoke(null,
new ErrorMessage
{
Message =
$"Splunk server HecUrl or HecToken not specified, skipping splunkServer '{splunkServer.SplunkHecUrl}'"
});
OnException?.Invoke(null, new ErrorMessage { Message = $"Invalid Splunk server configuration for '{splunkServer.SplunkHecUrl}'" });
continue;
}
try
{
var response = await splunkServer.SendAsync(splunkPayload);
if (!response.IsSuccessStatusCode)
{
OnException?.Invoke(null,
new ErrorMessage
{
Message =
$"Failed to send log to Splunk '{splunkServer.SplunkHecUrl}'. Status code: {response.StatusCode}"
});
OnException?.Invoke(null, new ErrorMessage { Message = $"Failed to send log to Splunk '{splunkServer.SplunkHecUrl}'. Status code: {response.StatusCode}" });
}
}
catch (Exception exception)
catch (Exception ex)
{
OnException?.Invoke(null,
new ErrorMessage
{
Exception = exception,
Message =
$"Error while logging to Splunk Server '{splunkServer.SplunkHecUrl}': {exception.Message}"
});
OnException?.Invoke(null, new ErrorMessage { Exception = ex, Message = $"Error logging to Splunk '{splunkServer.SplunkHecUrl}': {ex.Message}" });
}
}
}
@@ -247,7 +202,7 @@ internal static class LogHelper
var gelfMessage = new
{
version,
host = Environment.MachineName,
host = MachineName,
short_message = message,
level = logLevel.ToGrayLogLevel(),
facility,

643
EonaCat.Logger/Managers/LogManager.cs
View File

@@ -1,272 +1,263 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using EonaCat.Logger.EonaCatCoreLogger;
using EonaCat.Logger.EonaCatCoreLogger.Extensions;
using EonaCat.Logger.EonaCatCoreLogger.Models;
using EonaCat.Logger.Extensions;
using EonaCat.Logger.Syslog;
using Microsoft.Extensions.DependencyInjection;
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 DateTime _logDate;
private bool _isDisposing;
private string _category;
public LogManager(LoggerSettings settings, string serverIp, int serverPort)
{
if (string.IsNullOrEmpty(serverIp))
{
throw new ArgumentNullException(nameof(serverIp));
}
if (serverPort < 0)
{
throw new ArgumentException("Server port must be zero or greater.");
}
settings.SysLogServers = new List<SyslogServer>
{
new(serverIp, serverPort)
};
Settings = settings;
SetupLogManager();
}
public LogManager(LoggerSettings settings, string category = null)
{
_category = category;
if (string.IsNullOrWhiteSpace(category))
{
_category = "General";
}
Settings = settings;
SetupFileLogger(settings);
SetupLogManager();
LogHelper.OnException += LogHelper_OnException;
LogHelper.OnLogLevelDisabled += LogHelper_OnLogLevelDisabled;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using EonaCat.Logger.EonaCatCoreLogger;
using EonaCat.Logger.EonaCatCoreLogger.Extensions;
using EonaCat.Logger.EonaCatCoreLogger.Models;
using EonaCat.Logger.Extensions;
using EonaCat.Logger.Syslog;
using Microsoft.Extensions.DependencyInjection;
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 DateTime _logDate;
private bool _isDisposing;
private string _category;
public LogManager(LoggerSettings settings, string serverIp, int serverPort)
{
if (string.IsNullOrEmpty(serverIp))
{
throw new ArgumentNullException(nameof(serverIp));
}
if (serverPort < 0)
{
throw new ArgumentException("Server port must be zero or greater.");
}
settings.SysLogServers = new List<SyslogServer>
{
new(serverIp, serverPort)
};
Settings = settings;
SetupLogManager();
}
private void LogHelper_OnLogLevelDisabled(object sender, ErrorMessage e)
{
OnLogLevelDisabled?.Invoke(sender, e);
public LogManager(LoggerSettings settings, string category = null)
{
_category = category;
if (string.IsNullOrWhiteSpace(category))
{
_category = "General";
}
Settings = settings;
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;
public ILoggerProvider LoggerProvider { get; private set; }
public ILoggerFactory LoggerFactory { get; private set; }
public ILogger Logger { get; private set; }
public string CurrentLogFile => LoggerProvider is FileLoggerProvider fileLoggerProvider
? fileLoggerProvider.LogFile
: string.Empty;
public bool IsRunning { get; private set; }
public static LogManager Instance => _instance.Value;
public LoggerSettings Settings { get; set; } = CreateDefaultSettings();
public void Dispose()
{
DisposeAsync(true).GetAwaiter().GetResult();
GC.SuppressFinalize(this);
}
public async Task WriteAsync(Exception exception, string module = null, string method = null,
bool criticalException = false,
bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null,
string customSplunkSourceType = null, bool? sendToGrayLogServers = null, string grayLogFacility = null,
string grayLogSource = null, string grayLogVersion = "1.1")
{
if (exception == null)
{
return;
}
await WriteAsync(exception.FormatExceptionToMessage(module, method),
criticalException ? ELogType.CRITICAL : ELogType.ERROR, writeToConsole, sendToSysLogServers,
sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogFacility, grayLogSource,
grayLogVersion);
}
public async Task WriteAsync(string message, ELogType logType = ELogType.INFO, bool? writeToConsole = null,
bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string customSplunkSourceType = null,
bool? sendToGrayLogServers = null, string grayLogFacility = null, string grayLogSource = null,
string grayLogVersion = "1.1")
{
if (logType == ELogType.NONE)
{
return;
}
await InternalWriteAsync(CurrentDateTime, message, logType, writeToConsole, sendToSysLogServers, sendToSplunkServers,
customSplunkSourceType, sendToGrayLogServers, grayLogFacility, grayLogSource, grayLogVersion);
}
private DateTime CurrentDateTime => Settings.UseLocalTime ? DateTime.Now : DateTime.UtcNow;
public ILoggerProvider LoggerProvider { get; private set; }
public ILoggerFactory LoggerFactory { get; private set; }
public ILogger Logger { get; private set; }
public string CurrentLogFile => LoggerProvider is FileLoggerProvider fileLoggerProvider
? fileLoggerProvider.LogFile
: string.Empty;
public bool IsRunning { get; private set; }
public static LogManager Instance => _instance.Value;
public LoggerSettings Settings { get; set; } = CreateDefaultSettings();
public void Dispose()
{
DisposeAsync(true).GetAwaiter().GetResult();
GC.SuppressFinalize(this);
}
public async Task WriteAsync(Exception exception, string module = null, string method = null,
bool criticalException = false,
bool? writeToConsole = null, bool? sendToSysLogServers = null, bool? sendToSplunkServers = null,
string customSplunkSourceType = null, bool? sendToGrayLogServers = null, string grayLogFacility = null,
string grayLogSource = null, string grayLogVersion = "1.1")
{
if (exception == null)
{
return;
}
await WriteAsync(exception.FormatExceptionToMessage(module, method),
criticalException ? ELogType.CRITICAL : ELogType.ERROR, writeToConsole, sendToSysLogServers,
sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogFacility, grayLogSource,
grayLogVersion);
}
public async Task WriteAsync(string message, ELogType logType = ELogType.INFO, bool? writeToConsole = null,
bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string customSplunkSourceType = null,
bool? sendToGrayLogServers = null, string grayLogFacility = null, string grayLogSource = null,
string grayLogVersion = "1.1")
{
if (logType == ELogType.NONE)
{
return;
}
await InternalWriteAsync(CurrentDateTime, message, logType, writeToConsole, sendToSysLogServers, sendToSplunkServers,
customSplunkSourceType, sendToGrayLogServers, grayLogFacility, grayLogSource, grayLogVersion);
}
/// <summary>
/// Gets fired when an exception occurs during logging
/// </summary>
public event EventHandler<ErrorMessage> OnException;
/// </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 = "EonaCatLogger",
MaxLogType = ELogType.INFO
};
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)
{
return;
}
if (IsRunning && CurrentDateTime.Date > _logDate.Date)
{
await StopLoggingAsync();
}
IsRunning = true;
CreateLogger();
Directory.CreateDirectory(Settings.FileLoggerOptions.LogDirectory);
_logDate = CurrentDateTime;
}
private void CreateLogger()
{
// Dispose of previous ServiceProvider if it exists
LoggerProvider?.Dispose();
LoggerFactory?.Dispose();
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(builder => builder.SetMinimumLevel(Settings.MaxLogType.ToLogLevel())
.AddEonaCatFileLogger(configuration =>
{
var fileLoggerOptions = Settings.FileLoggerOptions;
configuration.MaxWriteTries = fileLoggerOptions.MaxWriteTries;
configuration.RetainedFileCountLimit = fileLoggerOptions.RetainedFileCountLimit;
configuration.FlushPeriod = fileLoggerOptions.FlushPeriod;
configuration.IsEnabled = fileLoggerOptions.IsEnabled;
configuration.BatchSize = fileLoggerOptions.BatchSize;
configuration.FileSizeLimit = fileLoggerOptions.FileSizeLimit;
configuration.LogDirectory = fileLoggerOptions.LogDirectory;
configuration.FileNamePrefix = fileLoggerOptions.FileNamePrefix;
configuration.MaxRolloverFiles = fileLoggerOptions.MaxRolloverFiles;
configuration.UseLocalTime = Settings.UseLocalTime;
configuration.UseMask = Settings.UseMask;
configuration.Mask = fileLoggerOptions.Mask;
configuration.UseDefaultMasking = Settings.UseDefaultMasking;
configuration.MaskedKeywords = fileLoggerOptions.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, bool? sendToSyslogServers = null, bool? sendToSplunkServers = null,
string customSplunkSourceType = null, bool? sendToGrayLogServers = null, string grayLogFacility = null,
string grayLogSource = null, string grayLogVersion = "1.1")
{
if (string.IsNullOrEmpty(message) || logType == ELogType.NONE ||
!IsLogLevelEnabled(logType))
{
return;
}
if (_isDisposing)
{
return;
}
if (!IsRunning)
{
await StartNewLogAsync();
}
var messageWithHeader = LogHelper.FormatMessageWithHeader(Settings, logType, message, dateTime, _category);
var writeToConsoleValue = writeToConsole ?? Settings.EnableConsole;
var sendToSyslogServersValue = sendToSyslogServers ?? Settings.SendToSyslogServers;
var sendToSplunkServersValue = sendToSplunkServers ?? Settings.SendToSplunkServers;
var sendToGrayLogServersValue = sendToGrayLogServers ?? Settings.SendToGrayLogServers;
LogHelper.SendToFile(Logger, Settings, logType, message);
if (writeToConsoleValue)
{
LogHelper.SendToConsole(Settings, logType, messageWithHeader, true);
}
var tasks = new List<Task>();
if (sendToSyslogServersValue || sendToSplunkServersValue || sendToGrayLogServersValue)
{
if (sendToSyslogServersValue)
{
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));
}
await Task.WhenAll(tasks);
}
var logMessage = new EonaCatLogMessage
{
DateTime = dateTime,
Message = message,
LogType = logType,
Origin = string.IsNullOrWhiteSpace(Settings.LogOrigin) ? "LogManager" : Settings.LogOrigin
};
Settings.OnLogEvent(logMessage);
/// </summary>
public event EventHandler<ErrorMessage> OnLogLevelDisabled;
private static LoggerSettings CreateDefaultSettings()
{
var settings = new LoggerSettings
{
Id = "EonaCatLogger",
MaxLogType = ELogType.INFO
};
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)
{
return;
}
if (IsRunning && CurrentDateTime.Date > _logDate.Date)
{
await StopLoggingAsync();
}
IsRunning = true;
CreateLogger();
Directory.CreateDirectory(Settings.FileLoggerOptions.LogDirectory);
_logDate = CurrentDateTime;
}
private void CreateLogger()
{
// Dispose of previous ServiceProvider if it exists
LoggerProvider?.Dispose();
LoggerFactory?.Dispose();
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(builder => builder.SetMinimumLevel(Settings.MaxLogType.ToLogLevel())
.AddEonaCatFileLogger(configuration =>
{
var fileLoggerOptions = Settings.FileLoggerOptions;
configuration.MaxWriteTries = fileLoggerOptions.MaxWriteTries;
configuration.RetainedFileCountLimit = fileLoggerOptions.RetainedFileCountLimit;
configuration.FlushPeriod = fileLoggerOptions.FlushPeriod;
configuration.IsEnabled = fileLoggerOptions.IsEnabled;
configuration.BatchSize = fileLoggerOptions.BatchSize;
configuration.FileSizeLimit = fileLoggerOptions.FileSizeLimit;
configuration.LogDirectory = fileLoggerOptions.LogDirectory;
configuration.FileNamePrefix = fileLoggerOptions.FileNamePrefix;
configuration.MaxRolloverFiles = fileLoggerOptions.MaxRolloverFiles;
configuration.UseLocalTime = Settings.UseLocalTime;
configuration.UseMask = Settings.UseMask;
configuration.Mask = fileLoggerOptions.Mask;
configuration.UseDefaultMasking = Settings.UseDefaultMasking;
configuration.MaskedKeywords = fileLoggerOptions.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, bool? sendToSyslogServers = null, bool? sendToSplunkServers = null,
string customSplunkSourceType = null, bool? sendToGrayLogServers = null, string grayLogFacility = null,
string grayLogSource = null, string grayLogVersion = "1.1")
{
if (string.IsNullOrWhiteSpace(message) || logType == ELogType.NONE || !IsLogLevelEnabled(logType) || _isDisposing)
{
return;
}
if (!IsRunning)
{
await StartNewLogAsync().ConfigureAwait(false);
}
var messageWithHeader = LogHelper.FormatMessageWithHeader(Settings, logType, message, dateTime, _category);
var writeToConsoleValue = writeToConsole.GetValueOrDefault(Settings.EnableConsole);
var sendToSyslogServersValue = sendToSyslogServers.GetValueOrDefault(Settings.SendToSyslogServers);
var sendToSplunkServersValue = sendToSplunkServers.GetValueOrDefault(Settings.SendToSplunkServers);
var sendToGrayLogServersValue = sendToGrayLogServers.GetValueOrDefault(Settings.SendToGrayLogServers);
LogHelper.SendToFile(Logger, Settings, logType, message);
if (writeToConsoleValue)
{
LogHelper.SendToConsole(Settings, logType, messageWithHeader, true);
}
var tasks = new List<Task>(3);
if (sendToSyslogServersValue)
{
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 (tasks.Count > 0)
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
var logMessage = new EonaCatLogMessage
{
DateTime = dateTime,
Message = message,
LogType = logType,
Origin = string.IsNullOrEmpty(Settings.LogOrigin) ? "LogManager" : Settings.LogOrigin
};
Settings.OnLogEvent(logMessage);
}
private bool IsLogLevelEnabled(ELogType logType)
@@ -285,69 +276,69 @@ namespace EonaCat.Logger.Managers
return isEnabled;
}
public void Reset()
{
Settings.ResetLogEvent();
}
private void LogHelper_OnException(object sender, ErrorMessage e)
{
OnException?.Invoke(sender, e);
}
private void SetupFileLogger(LoggerSettings settings = null, string logFolder = null, bool defaultPrefix = true)
{
if (settings == null)
{
settings = Settings;
}
if (!settings.EnableFileLogging)
{
return;
}
if (logFolder != null)
{
settings.FileLoggerOptions.LogDirectory = logFolder;
}
if (string.IsNullOrWhiteSpace(settings.FileLoggerOptions.FileNamePrefix))
{
settings.FileLoggerOptions.FileNamePrefix = defaultPrefix ? "EonaCat" : string.Empty;
}
}
private void SetupLogManager()
{
AppDomain.CurrentDomain.ProcessExit += ProcessExit;
_logDate = CurrentDateTime;
}
private void ProcessExit(object sender, EventArgs e)
{
Dispose();
}
private Task StopLoggingAsync()
{
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);
}
}
}
public void Reset()
{
Settings.ResetLogEvent();
}
private void LogHelper_OnException(object sender, ErrorMessage e)
{
OnException?.Invoke(sender, e);
}
private void SetupFileLogger(LoggerSettings settings = null, string logFolder = null, bool defaultPrefix = true)
{
if (settings == null)
{
settings = Settings;
}
if (!settings.EnableFileLogging)
{
return;
}
if (logFolder != null)
{
settings.FileLoggerOptions.LogDirectory = logFolder;
}
if (string.IsNullOrWhiteSpace(settings.FileLoggerOptions.FileNamePrefix))
{
settings.FileLoggerOptions.FileNamePrefix = defaultPrefix ? "EonaCat" : string.Empty;
}
}
private void SetupLogManager()
{
AppDomain.CurrentDomain.ProcessExit += ProcessExit;
_logDate = CurrentDateTime;
}
private void ProcessExit(object sender, EventArgs e)
{
Dispose();
}
private Task StopLoggingAsync()
{
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);
}
}
}
}