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

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

@@ -1,5 +1,6 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using System.Net; using System.Net;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
@@ -27,89 +28,49 @@ internal static class LogHelper
internal static event EventHandler<ErrorMessage> OnLogLevelDisabled; 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, internal static string FormatMessageWithHeader(LoggerSettings settings, ELogType logType, string currentMessage,
DateTime dateTime, string category = null) 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 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("{category}", $"[Category:{category}]")
.Replace("{thread}", $"[ThreadId:{Environment.CurrentManagedThreadId}]") .Replace("{thread}", $"[ThreadId:{Environment.CurrentManagedThreadId}]")
.Replace("{sev}", $"[{logType}]"); .Replace("{sev}", $"[{logType}]");
if (!settings?.RemoveMessagePrefix ?? (false && !currentMessage.Contains("[EonaCatLogger]"))) if (!(settings?.RemoveMessagePrefix ?? false) && !currentMessage.Contains("[EonaCatLogger]"))
{ {
sb.Insert(0, "[EonaCatLogger] "); sb.Insert(0, "[EonaCatLogger] ");
} }
sb.Append(" ").Append(currentMessage); sb.Append(" ").Append(currentMessage);
return sb.ToString(); return sb.ToString();
} }
internal static void SendToConsole(LoggerSettings settings, ELogType logType, string message, bool writeToConsole) 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) if (settings.EnableColors && settings.Colors != null)
{ {
var prevForeground = Console.ForegroundColor; var prevForeground = Console.ForegroundColor;
var prevBackground = Console.BackgroundColor; 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.WriteLine(message);
Console.ForegroundColor = prevForeground; Console.ForegroundColor = prevForeground;
Console.BackgroundColor = prevBackground; 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 || 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 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) private static bool IsLogLevelEnabled(LoggerSettings loggerSettings, ELogType logType)
{ {
if (loggerSettings == null) if (loggerSettings == null)
@@ -146,8 +126,9 @@ internal static class LogHelper
var isEnabled = loggerSettings.MaxLogType != ELogType.NONE && logType <= loggerSettings.MaxLogType; var isEnabled = loggerSettings.MaxLogType != ELogType.NONE && logType <= loggerSettings.MaxLogType;
if (!isEnabled) 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; return isEnabled;
} }
@@ -161,55 +142,29 @@ internal static class LogHelper
logger.Log(logLevel, message); 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) if (settings == null || !sendToSplunkServer || splunkPayload == null) return;
{
return;
}
if (settings.SplunkServers == null) foreach (var splunkServer in settings.SplunkServers ?? Enumerable.Empty<SplunkServer.SplunkServer>())
{
settings.SplunkServers = new List<SplunkServer.SplunkServer>();
}
foreach (var splunkServer in settings.SplunkServers)
{ {
if (!splunkServer.HasHecUrl || !splunkServer.HasHecToken) if (!splunkServer.HasHecUrl || !splunkServer.HasHecToken)
{ {
OnException?.Invoke(null, OnException?.Invoke(null, new ErrorMessage { Message = $"Invalid Splunk server configuration for '{splunkServer.SplunkHecUrl}'" });
new ErrorMessage
{
Message =
$"Splunk server HecUrl or HecToken not specified, skipping splunkServer '{splunkServer.SplunkHecUrl}'"
});
continue; continue;
} }
try try
{ {
var response = await splunkServer.SendAsync(splunkPayload); var response = await splunkServer.SendAsync(splunkPayload);
if (!response.IsSuccessStatusCode) if (!response.IsSuccessStatusCode)
{ {
OnException?.Invoke(null, OnException?.Invoke(null, new ErrorMessage { Message = $"Failed to send log to Splunk '{splunkServer.SplunkHecUrl}'. Status code: {response.StatusCode}" });
new ErrorMessage
{
Message =
$"Failed to send log to Splunk '{splunkServer.SplunkHecUrl}'. Status code: {response.StatusCode}"
});
} }
} }
catch (Exception exception) catch (Exception ex)
{ {
OnException?.Invoke(null, OnException?.Invoke(null, new ErrorMessage { Exception = ex, Message = $"Error logging to Splunk '{splunkServer.SplunkHecUrl}': {ex.Message}" });
new ErrorMessage
{
Exception = exception,
Message =
$"Error while logging to Splunk Server '{splunkServer.SplunkHecUrl}': {exception.Message}"
});
} }
} }
} }
@@ -247,7 +202,7 @@ internal static class LogHelper
var gelfMessage = new var gelfMessage = new
{ {
version, version,
host = Environment.MachineName, host = MachineName,
short_message = message, short_message = message,
level = logLevel.ToGrayLogLevel(), level = logLevel.ToGrayLogLevel(),
facility, facility,

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

@@ -1,272 +1,263 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using EonaCat.Logger.EonaCatCoreLogger; using EonaCat.Logger.EonaCatCoreLogger;
using EonaCat.Logger.EonaCatCoreLogger.Extensions; using EonaCat.Logger.EonaCatCoreLogger.Extensions;
using EonaCat.Logger.EonaCatCoreLogger.Models; using EonaCat.Logger.EonaCatCoreLogger.Models;
using EonaCat.Logger.Extensions; using EonaCat.Logger.Extensions;
using EonaCat.Logger.Syslog; using EonaCat.Logger.Syslog;
using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace EonaCat.Logger.Managers namespace EonaCat.Logger.Managers
{ {
// This file is part of the EonaCat project(s) which is released under the Apache License. // 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. // See the LICENSE file or go to https://EonaCat.com/License for full license details.
public class LogManager : ILogManager, IDisposable public class LogManager : ILogManager, IDisposable
{ {
private static readonly Lazy<LogManager> _instance = new(() => new LogManager(CreateDefaultSettings())); private static readonly Lazy<LogManager> _instance = new(() => new LogManager(CreateDefaultSettings()));
private readonly CancellationTokenSource _tokenSource = new(); private readonly CancellationTokenSource _tokenSource = new();
private DateTime _logDate; private DateTime _logDate;
private bool _isDisposing; private bool _isDisposing;
private string _category; private string _category;
public LogManager(LoggerSettings settings, string serverIp, int serverPort) public LogManager(LoggerSettings settings, string serverIp, int serverPort)
{ {
if (string.IsNullOrEmpty(serverIp)) if (string.IsNullOrEmpty(serverIp))
{ {
throw new ArgumentNullException(nameof(serverIp)); throw new ArgumentNullException(nameof(serverIp));
} }
if (serverPort < 0) if (serverPort < 0)
{ {
throw new ArgumentException("Server port must be zero or greater."); throw new ArgumentException("Server port must be zero or greater.");
} }
settings.SysLogServers = new List<SyslogServer> settings.SysLogServers = new List<SyslogServer>
{ {
new(serverIp, serverPort) new(serverIp, serverPort)
}; };
Settings = settings; Settings = settings;
SetupLogManager(); 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;
} }
private void LogHelper_OnLogLevelDisabled(object sender, ErrorMessage e) public LogManager(LoggerSettings settings, string category = null)
{ {
OnLogLevelDisabled?.Invoke(sender, e); _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> /// <summary>
/// Gets fired when an exception occurs during logging /// Gets fired when an exception occurs during logging
/// </summary> /// </summary>
public event EventHandler<ErrorMessage> OnException; public event EventHandler<ErrorMessage> OnException;
/// <summary> /// <summary>
/// Gets fired when the log level is disabled and the user tries to log a message /// Gets fired when the log level is disabled and the user tries to log a message
/// </summary> /// </summary>
public event EventHandler<ErrorMessage> OnLogLevelDisabled; public event EventHandler<ErrorMessage> OnLogLevelDisabled;
private static LoggerSettings CreateDefaultSettings() private static LoggerSettings CreateDefaultSettings()
{ {
var settings = new LoggerSettings var settings = new LoggerSettings
{ {
Id = "EonaCatLogger", Id = "EonaCatLogger",
MaxLogType = ELogType.INFO MaxLogType = ELogType.INFO
}; };
return settings; return settings;
} }
protected virtual async Task DisposeAsync(bool disposing) protected virtual async Task DisposeAsync(bool disposing)
{ {
if (disposing) if (disposing)
{ {
_isDisposing = true; _isDisposing = true;
await StopLoggingAsync(); await StopLoggingAsync();
await Task.Delay(100); await Task.Delay(100);
} }
} }
public async Task StartNewLogAsync() public async Task StartNewLogAsync()
{ {
if (_tokenSource.IsCancellationRequested) if (_tokenSource.IsCancellationRequested)
{ {
return; return;
} }
if (IsRunning && CurrentDateTime.Date > _logDate.Date) if (IsRunning && CurrentDateTime.Date > _logDate.Date)
{ {
await StopLoggingAsync(); await StopLoggingAsync();
} }
IsRunning = true; IsRunning = true;
CreateLogger(); CreateLogger();
Directory.CreateDirectory(Settings.FileLoggerOptions.LogDirectory); Directory.CreateDirectory(Settings.FileLoggerOptions.LogDirectory);
_logDate = CurrentDateTime; _logDate = CurrentDateTime;
} }
private void CreateLogger() private void CreateLogger()
{ {
// Dispose of previous ServiceProvider if it exists // Dispose of previous ServiceProvider if it exists
LoggerProvider?.Dispose(); LoggerProvider?.Dispose();
LoggerFactory?.Dispose(); LoggerFactory?.Dispose();
IServiceCollection serviceCollection = new ServiceCollection(); IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(builder => builder.SetMinimumLevel(Settings.MaxLogType.ToLogLevel()) serviceCollection.AddLogging(builder => builder.SetMinimumLevel(Settings.MaxLogType.ToLogLevel())
.AddEonaCatFileLogger(configuration => .AddEonaCatFileLogger(configuration =>
{ {
var fileLoggerOptions = Settings.FileLoggerOptions; var fileLoggerOptions = Settings.FileLoggerOptions;
configuration.MaxWriteTries = fileLoggerOptions.MaxWriteTries; configuration.MaxWriteTries = fileLoggerOptions.MaxWriteTries;
configuration.RetainedFileCountLimit = fileLoggerOptions.RetainedFileCountLimit; configuration.RetainedFileCountLimit = fileLoggerOptions.RetainedFileCountLimit;
configuration.FlushPeriod = fileLoggerOptions.FlushPeriod; configuration.FlushPeriod = fileLoggerOptions.FlushPeriod;
configuration.IsEnabled = fileLoggerOptions.IsEnabled; configuration.IsEnabled = fileLoggerOptions.IsEnabled;
configuration.BatchSize = fileLoggerOptions.BatchSize; configuration.BatchSize = fileLoggerOptions.BatchSize;
configuration.FileSizeLimit = fileLoggerOptions.FileSizeLimit; configuration.FileSizeLimit = fileLoggerOptions.FileSizeLimit;
configuration.LogDirectory = fileLoggerOptions.LogDirectory; configuration.LogDirectory = fileLoggerOptions.LogDirectory;
configuration.FileNamePrefix = fileLoggerOptions.FileNamePrefix; configuration.FileNamePrefix = fileLoggerOptions.FileNamePrefix;
configuration.MaxRolloverFiles = fileLoggerOptions.MaxRolloverFiles; configuration.MaxRolloverFiles = fileLoggerOptions.MaxRolloverFiles;
configuration.UseLocalTime = Settings.UseLocalTime; configuration.UseLocalTime = Settings.UseLocalTime;
configuration.UseMask = Settings.UseMask; configuration.UseMask = Settings.UseMask;
configuration.Mask = fileLoggerOptions.Mask; configuration.Mask = fileLoggerOptions.Mask;
configuration.UseDefaultMasking = Settings.UseDefaultMasking; configuration.UseDefaultMasking = Settings.UseDefaultMasking;
configuration.MaskedKeywords = fileLoggerOptions.MaskedKeywords; configuration.MaskedKeywords = fileLoggerOptions.MaskedKeywords;
})); }));
var serviceProvider = serviceCollection.BuildServiceProvider(); var serviceProvider = serviceCollection.BuildServiceProvider();
LoggerProvider = serviceProvider.GetService<ILoggerProvider>(); LoggerProvider = serviceProvider.GetService<ILoggerProvider>();
LoggerFactory = serviceProvider.GetService<ILoggerFactory>(); LoggerFactory = serviceProvider.GetService<ILoggerFactory>();
Logger = LoggerFactory.CreateLogger(Settings.Id); Logger = LoggerFactory.CreateLogger(Settings.Id);
LogHelper.SendToFile(Logger, Settings, ELogType.INFO, LogHelper.GetStartupMessage()); LogHelper.SendToFile(Logger, Settings, ELogType.INFO, LogHelper.GetStartupMessage());
} }
private async Task InternalWriteAsync(DateTime dateTime, string message, ELogType logType = ELogType.INFO, 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)
!IsLogLevelEnabled(logType)) {
{ return;
return; }
}
if (!IsRunning)
if (_isDisposing) {
{ await StartNewLogAsync().ConfigureAwait(false);
return; }
}
var messageWithHeader = LogHelper.FormatMessageWithHeader(Settings, logType, message, dateTime, _category);
if (!IsRunning) var writeToConsoleValue = writeToConsole.GetValueOrDefault(Settings.EnableConsole);
{ var sendToSyslogServersValue = sendToSyslogServers.GetValueOrDefault(Settings.SendToSyslogServers);
await StartNewLogAsync(); var sendToSplunkServersValue = sendToSplunkServers.GetValueOrDefault(Settings.SendToSplunkServers);
} var sendToGrayLogServersValue = sendToGrayLogServers.GetValueOrDefault(Settings.SendToGrayLogServers);
var messageWithHeader = LogHelper.FormatMessageWithHeader(Settings, logType, message, dateTime, _category); LogHelper.SendToFile(Logger, Settings, logType, message);
var writeToConsoleValue = writeToConsole ?? Settings.EnableConsole;
var sendToSyslogServersValue = sendToSyslogServers ?? Settings.SendToSyslogServers; if (writeToConsoleValue)
var sendToSplunkServersValue = sendToSplunkServers ?? Settings.SendToSplunkServers; {
var sendToGrayLogServersValue = sendToGrayLogServers ?? Settings.SendToGrayLogServers; LogHelper.SendToConsole(Settings, logType, messageWithHeader, true);
}
LogHelper.SendToFile(Logger, Settings, logType, message);
var tasks = new List<Task>(3);
if (writeToConsoleValue) if (sendToSyslogServersValue)
{ {
LogHelper.SendToConsole(Settings, logType, messageWithHeader, true); tasks.Add(LogHelper.SendToSysLogServersAsync(Settings, messageWithHeader, true));
} }
if (sendToSplunkServersValue)
var tasks = new List<Task>(); {
if (sendToSyslogServersValue || sendToSplunkServersValue || sendToGrayLogServersValue) tasks.Add(LogHelper.SendToSplunkServersAsync(Settings, customSplunkSourceType ?? logType.ToString(),
{ messageWithHeader, true));
if (sendToSyslogServersValue) }
{ if (sendToGrayLogServersValue)
tasks.Add(LogHelper.SendToSysLogServersAsync(Settings, messageWithHeader, true)); {
} tasks.Add(LogHelper.SendToGrayLogServersAsync(Settings, messageWithHeader, logType, grayLogFacility,
grayLogSource, true, grayLogVersion));
if (sendToSplunkServersValue) }
{
tasks.Add(LogHelper.SendToSplunkServersAsync(Settings, customSplunkSourceType ?? logType.ToString(), if (tasks.Count > 0)
messageWithHeader, true)); {
} await Task.WhenAll(tasks).ConfigureAwait(false);
}
if (sendToGrayLogServersValue)
{ var logMessage = new EonaCatLogMessage
tasks.Add(LogHelper.SendToGrayLogServersAsync(Settings, messageWithHeader, logType, grayLogFacility, {
grayLogSource, true, grayLogVersion)); DateTime = dateTime,
} Message = message,
LogType = logType,
await Task.WhenAll(tasks); Origin = string.IsNullOrEmpty(Settings.LogOrigin) ? "LogManager" : Settings.LogOrigin
} };
Settings.OnLogEvent(logMessage);
var logMessage = new EonaCatLogMessage
{
DateTime = dateTime,
Message = message,
LogType = logType,
Origin = string.IsNullOrWhiteSpace(Settings.LogOrigin) ? "LogManager" : Settings.LogOrigin
};
Settings.OnLogEvent(logMessage);
} }
private bool IsLogLevelEnabled(ELogType logType) private bool IsLogLevelEnabled(ELogType logType)
@@ -285,69 +276,69 @@ namespace EonaCat.Logger.Managers
return isEnabled; return isEnabled;
} }
public void Reset() public void Reset()
{ {
Settings.ResetLogEvent(); Settings.ResetLogEvent();
} }
private void LogHelper_OnException(object sender, ErrorMessage e) private void LogHelper_OnException(object sender, ErrorMessage e)
{ {
OnException?.Invoke(sender, e); OnException?.Invoke(sender, e);
} }
private void SetupFileLogger(LoggerSettings settings = null, string logFolder = null, bool defaultPrefix = true) private void SetupFileLogger(LoggerSettings settings = null, string logFolder = null, bool defaultPrefix = true)
{ {
if (settings == null) if (settings == null)
{ {
settings = Settings; settings = Settings;
} }
if (!settings.EnableFileLogging) if (!settings.EnableFileLogging)
{ {
return; return;
} }
if (logFolder != null) if (logFolder != null)
{ {
settings.FileLoggerOptions.LogDirectory = logFolder; settings.FileLoggerOptions.LogDirectory = logFolder;
} }
if (string.IsNullOrWhiteSpace(settings.FileLoggerOptions.FileNamePrefix)) if (string.IsNullOrWhiteSpace(settings.FileLoggerOptions.FileNamePrefix))
{ {
settings.FileLoggerOptions.FileNamePrefix = defaultPrefix ? "EonaCat" : string.Empty; settings.FileLoggerOptions.FileNamePrefix = defaultPrefix ? "EonaCat" : string.Empty;
} }
} }
private void SetupLogManager() private void SetupLogManager()
{ {
AppDomain.CurrentDomain.ProcessExit += ProcessExit; AppDomain.CurrentDomain.ProcessExit += ProcessExit;
_logDate = CurrentDateTime; _logDate = CurrentDateTime;
} }
private void ProcessExit(object sender, EventArgs e) private void ProcessExit(object sender, EventArgs e)
{ {
Dispose(); Dispose();
} }
private Task StopLoggingAsync() private Task StopLoggingAsync()
{ {
WriteStopMessage(); WriteStopMessage();
IsRunning = false; IsRunning = false;
return Task.CompletedTask; return Task.CompletedTask;
} }
private void WriteStopMessage() private void WriteStopMessage()
{ {
var stopMessage = $"{DllInfo.ApplicationName} stopped.{Environment.NewLine}"; var stopMessage = $"{DllInfo.ApplicationName} stopped.{Environment.NewLine}";
LogHelper.SendToFile(Logger, Settings, ELogType.INFO, stopMessage); LogHelper.SendToFile(Logger, Settings, ELogType.INFO, stopMessage);
} }
public void DeleteCurrentLogFile() public void DeleteCurrentLogFile()
{ {
if (!string.IsNullOrEmpty(CurrentLogFile)) if (!string.IsNullOrEmpty(CurrentLogFile))
{ {
File.Delete(CurrentLogFile); File.Delete(CurrentLogFile);
} }
} }
} }
} }