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

Updated

Browse Source
This commit is contained in:
EonaCat
2023-06-30 10:37:55 +02:00
parent 478aa15b4f
commit 1742537612
4 changed files with 141 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
EonaCat.Logger/EonaCat.Logger.csproj
View File

@@ -8,7 +8,7 @@
net7.0;
</TargetFrameworks>
<ApplicationIcon>icon.ico</ApplicationIcon>
<Version>1.1.0</Version>
<Version>1.1.1</Version>
<Authors>EonaCat (Jeroen Saey)</Authors>
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
<Company>EonaCat (Jeroen Saey)</Company>

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

@@ -16,70 +16,45 @@ namespace EonaCat.Logger.Managers
{
private static readonly object FileLock = new object();
/// <summary>
/// Format a message with the specified header
/// </summary>
/// <param name="settings">Logger settings</param>
/// <param name="logType">logtype for the formatted message</param>
/// <param name="currentMessage">The actual message to format with the header</param>
/// <param name="dateTime">The dateTime of the message</param>
/// <returns></returns>
public static string FormatMessageWithHeader(LoggerSettings settings, ELogType logType, string currentMessage, DateTime dateTime)
internal static string FormatMessageWithHeader(LoggerSettings settings, ELogType logType, string currentMessage, DateTime dateTime)
{
if (string.IsNullOrWhiteSpace(currentMessage))
{
return currentMessage;
}
if (settings == null)
{
return "[EonaCatLogger]" + " " + currentMessage;
}
string header = settings?.HeaderFormat ?? "[EonaCatLogger]";
string header = settings.HeaderFormat;
if (header.Contains("{ts}"))
{
header = header.Replace("{ts}", dateTime.ToString(settings.TimestampFormat));
}
header = header.Replace("{ts}", dateTime.ToString(settings?.TimestampFormat));
if (header.Contains("{host}"))
{
header = header.Replace("{host}", Dns.GetHostName());
}
if (header.Contains("{thread}"))
{
header = header.Replace("{thread}", Thread.CurrentThread.ManagedThreadId.ToString());
}
if (header.Contains("{sev}"))
{
header = header.Replace("{sev}", logType.ToString());
}
string fullMessage = AddHeaderIfNotExists(header, currentMessage);
string fullMessage = AddHeaderIfNotExists(settings, header, currentMessage);
return fullMessage;
}
private static string AddHeaderIfNotExists(string header, string currentMessage)
private static string AddHeaderIfNotExists(LoggerSettings settings, string header, string currentMessage)
{
if (!currentMessage.Contains("[EonaCatLogger]"))
if (settings == null || !settings.RemoveMessagePrefix)
{
return "[EonaCatLogger]" + " " + header + " " + currentMessage;
if (!currentMessage.Contains("[EonaCatLogger]"))
return "[EonaCatLogger] " + header + " " + currentMessage;
}
return currentMessage;
return header + " " + currentMessage;
}
/// <summary>
/// Formats a given exception as a string
/// </summary>
/// <param name="exception">exception</param>
/// <param name="module">The name of the module which called the code (optional)</param>
/// <param name="method">The name of the method which waws called in code (optional)</param>
/// <returns></returns>
public static string FormatExceptionToMessage(this Exception exception, string module = null, string method = null)
{
if (exception == null) return string.Empty;
if (exception == null)
return string.Empty;
var st = new StackTrace(exception, true);
var frame = st.GetFrame(0);
int fileLine = frame.GetFileLineNumber();
@@ -90,49 +65,9 @@ namespace EonaCat.Logger.Managers
"--- Exception details provided by EonaCatLogger ---" + Environment.NewLine +
(!string.IsNullOrEmpty(module) ? " Module : " + module + Environment.NewLine : "") +
(!string.IsNullOrEmpty(method) ? " Method : " + method + Environment.NewLine : "") +
" Type : " + exception.GetType().ToString() + Environment.NewLine;
if (exception.Data != null && exception.Data.Count > 0)
{
message += " Data : " + Environment.NewLine;
foreach (DictionaryEntry curr in exception.Data)
{
message += " | " + curr.Key + ": " + curr.Value + Environment.NewLine;
}
}
else
{
message += " Data : (none)" + Environment.NewLine;
}
message +=
" Inner : ";
if (exception.InnerException == null) message += "(null)" + Environment.NewLine;
else
{
message += exception.InnerException.GetType().ToString() + Environment.NewLine;
message +=
" Message : " + exception.InnerException.Message + Environment.NewLine +
" Source : " + exception.InnerException.Source + Environment.NewLine +
" StackTrace : " + exception.InnerException.StackTrace + Environment.NewLine +
" ToString : " + exception.InnerException.ToString() + Environment.NewLine;
if (exception.InnerException.Data != null && exception.InnerException.Data.Count > 0)
{
message += " Data : " + Environment.NewLine;
foreach (DictionaryEntry curr in exception.Data)
{
message += " | " + curr.Key + ": " + curr.Value + Environment.NewLine;
}
}
else
{
message += " Data : (none)" + Environment.NewLine;
}
}
message +=
" Type : " + exception.GetType().ToString() + Environment.NewLine +
" Data : " + (exception.Data != null && exception.Data.Count > 0 ? Environment.NewLine + FormatExceptionData(exception.Data) : "(none)") + Environment.NewLine +
" Inner : " + (exception.InnerException != null ? FormatInnerException(exception.InnerException) : "(null)") + Environment.NewLine +
" Message : " + exception.Message + Environment.NewLine +
" Source : " + exception.Source + Environment.NewLine +
" StackTrace : " + exception.StackTrace + Environment.NewLine +
@@ -140,14 +75,45 @@ namespace EonaCat.Logger.Managers
" File : " + filename + Environment.NewLine +
" ToString : " + exception.ToString() + Environment.NewLine +
"---";
return message;
}
private static string FormatExceptionData(IDictionary data)
{
StringBuilder sb = new StringBuilder();
foreach (DictionaryEntry entry in data)
{
sb.Append(" | ")
.Append(entry.Key)
.Append(": ")
.Append(entry.Value)
.Append(Environment.NewLine);
}
return sb.ToString();
}
private static string FormatInnerException(Exception innerException)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(innerException.GetType().ToString())
.AppendLine(" Message : " + innerException.Message)
.AppendLine(" Source : " + innerException.Source)
.AppendLine(" StackTrace : " + innerException.StackTrace)
.AppendLine(" ToString : " + innerException.ToString())
.Append(" Data : ")
.AppendLine(innerException.Data != null && innerException.Data.Count > 0 ? Environment.NewLine + FormatExceptionData(innerException.Data) : "(none)");
return sb.ToString();
}
internal static void SendConsole(LoggerSettings settings, ELogType logType, string message, bool writeToConsole)
{
if (settings == null) return;
if (!writeToConsole) return;
if (string.IsNullOrWhiteSpace(message)) return;
if (settings == null || !writeToConsole || string.IsNullOrWhiteSpace(message))
return;
if (settings.EnableColors)
{
@@ -203,10 +169,8 @@ namespace EonaCat.Logger.Managers
{
lock (FileLock)
{
if (logger == null) return;
if (settings == null) return;
if (!settings.EnableFileLogging) return;
if (string.IsNullOrWhiteSpace(message)) return;
if (logger == null || settings == null || !settings.EnableFileLogging || string.IsNullOrWhiteSpace(message))
return;
int tries = 0;
bool completed = false;
@@ -214,33 +178,29 @@ namespace EonaCat.Logger.Managers
{
try
{
if (logType == ELogType.CRITICAL)
switch (logType)
{
logger.LogCritical(message);
}
else if (logType == ELogType.DEBUG)
{
logger.LogDebug(message);
}
else if (logType == ELogType.ERROR)
{
logger.LogError(message);
}
else if (logType == ELogType.INFO)
{
logger.LogInformation(message);
}
else if (logType == ELogType.TRACE)
{
logger.LogTrace(message);
}
else if (logType == ELogType.TRAFFIC)
{
logger.LogTrace($"[TRAFFIC] {message}");
}
else if (logType == ELogType.WARNING)
{
logger.LogWarning(message);
case ELogType.CRITICAL:
logger.LogCritical(message);
break;
case ELogType.DEBUG:
logger.LogDebug(message);
break;
case ELogType.ERROR:
logger.LogError(message);
break;
case ELogType.INFO:
logger.LogInformation(message);
break;
case ELogType.TRACE:
logger.LogTrace(message);
break;
case ELogType.TRAFFIC:
logger.LogTrace($"[TRAFFIC] {message}");
break;
case ELogType.WARNING:
logger.LogWarning(message);
break;
}
completed = true;
}
@@ -251,15 +211,14 @@ namespace EonaCat.Logger.Managers
if (tries >= maxTries)
throw;
}
}
}
}
}
internal static void SendToSysLogServers(LoggerSettings settings, string message)
{
if (settings == null) return;
if (!settings.SendToSyslogServers) return;
if (string.IsNullOrWhiteSpace(message)) return;
if (settings == null || !settings.SendToSyslogServers || string.IsNullOrWhiteSpace(message))
return;
if (settings.SysLogServers == null || !settings.SysLogServers.Any())
{
@@ -294,4 +253,5 @@ namespace EonaCat.Logger.Managers
}
}
}
}

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

@@ -1,5 +1,4 @@
using EonaCat.Logger.Exceptions;
using EonaCat.Logger.Helpers;
using EonaCat.Logger.Syslog;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
@@ -20,66 +19,42 @@ namespace EonaCat.Logger.Managers
public partial class LogManager : ILogManager, IDisposable
{
private DateTime _logDate;
public ELogType LogType;
private ILoggerProvider LoggerProvider { get; set; }
private ILoggerFactory LoggerFactory { get; set; }
private ILogger Logger { get; set; }
public string CurrentLogFile => LoggerProvider != null ? ((FileLoggerProvider)LoggerProvider).LogFile : string.Empty;
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 StreamWriter Output { get; private set; }
public string CategoryName { get; set; }
public readonly string Id;
public string Id { get; }
private bool _disposed;
private static LogManager _instance;
private LoggerSettings _settings;
private readonly CancellationTokenSource _tokenSource = new CancellationTokenSource();
private CancellationToken _token;
/// <summary>
/// Default Logger Instance with it's default configuration
/// </summary>
public static LogManager Instance => InstanceInit();
/// <summary>
/// Logging settings.
/// </summary>
public LoggerSettings Settings
{
get
{
if (_settings == null)
{
_settings = new LoggerSettings();
}
_settings ??= new LoggerSettings();
return _settings;
}
set
{
_settings = value;
}
set => _settings = value;
}
private static LogManager InstanceInit()
{
if (_instance == null)
{
_instance = new LogManager(null, id: "EonaCat");
}
_instance ??= new LogManager(null, id: "EonaCat");
return _instance;
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
@@ -93,43 +68,38 @@ namespace EonaCat.Logger.Managers
private void StartNewLog()
{
if (_tokenSource.IsCancellationRequested)
{
return;
}
DateTime now = DateTime.Now;
DateTime now = DateTime.UtcNow;
if (IsRunning && now.Date > _logDate.Date)
{
StopLogging();
}
IsRunning = true;
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(builder => builder.AddEonaCatFileLogger(configuration =>
{
configuration.MaxWriteTries = Settings.FileLoggerOptions.MaxWriteTries;
configuration.RetainedFileCountLimit = Settings.FileLoggerOptions.RetainedFileCountLimit;
configuration.FlushPeriod = Settings.FileLoggerOptions.FlushPeriod;
configuration.IsEnabled = Settings.FileLoggerOptions.IsEnabled;
configuration.BatchSize = Settings.FileLoggerOptions.BatchSize;
configuration.FileSizeLimit = Settings.FileLoggerOptions.FileSizeLimit;
configuration.LogDirectory = Settings.FileLoggerOptions.LogDirectory;
configuration.FileNamePrefix = Settings.FileLoggerOptions.FileNamePrefix;
configuration.MaxRolloverFiles = Settings.FileLoggerOptions.MaxRolloverFiles;
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;
}));
var serviceProvider = serviceCollection.BuildServiceProvider();
LoggerProvider = serviceProvider.GetService<ILoggerProvider>();
LoggerFactory = serviceProvider.GetService<ILoggerFactory>();
CategoryName = CategoryName ?? string.Empty;
CategoryName ??= string.Empty;
Logger = LoggerFactory.CreateLogger(CategoryName);
if (!Directory.Exists(Settings.FileLoggerOptions.LogDirectory))
{
Directory.CreateDirectory(Settings.FileLoggerOptions.LogDirectory);
}
Directory.CreateDirectory(Settings.FileLoggerOptions.LogDirectory);
_logDate = now;
@@ -139,60 +109,35 @@ namespace EonaCat.Logger.Managers
public void Assert(bool condition, string message)
{
if (!condition)
{
throw new EonaCatLoggerAssertionException(message);
}
}
private void Write(DateTime dateTime, string message, ELogType logType = ELogType.INFO, bool? writeToConsole = null)
{
if (string.IsNullOrWhiteSpace(message)) return;
if (logType < ELogType.INFO) return;
if (string.IsNullOrEmpty(message) || logType < ELogType.INFO)
return;
string remainder = "";
string currentMessage;
if (message.Length > _settings.MaxMessageLength)
{
currentMessage = message.Substring(0, _settings.MaxMessageLength);
remainder = message.Substring(_settings.MaxMessageLength, (message.Length - _settings.MaxMessageLength));
}
else
{
currentMessage = message;
}
string currentMessage = message.Length > _settings.MaxMessageLength ? message.Substring(0, _settings.MaxMessageLength) : message;
string remainder = message.Length > _settings.MaxMessageLength ? message.Substring(_settings.MaxMessageLength) : "";
var fullMessage = LogHelper.FormatMessageWithHeader(_settings, logType, currentMessage, dateTime);
if (writeToConsole == null)
{
writeToConsole = _settings.EnableConsole;
}
LogHelper.SendConsole(_settings, logType, fullMessage, writeToConsole == true);
writeToConsole ??= _settings.EnableConsole;
LogHelper.SendConsole(_settings, logType, fullMessage, writeToConsole.Value);
LogHelper.SendFile(Logger, _settings, logType, fullMessage);
LogHelper.SendToSysLogServers(_settings, fullMessage);
if (!string.IsNullOrEmpty(remainder))
{
Write(dateTime, remainder, logType, writeToConsole);
}
var logMessage = new EonaCatLogMessage
{
DateTime = dateTime,
Message = currentMessage,
LogType = logType
LogType = logType,
Origin = string.IsNullOrWhiteSpace(Settings?.LogOrigin) ? "LogManager" : Settings.LogOrigin
};
if (Settings != null)
{
logMessage.Origin = string.IsNullOrWhiteSpace(Settings.LogOrigin) ? "LogManager" : Settings.LogOrigin;
Settings?.OnLogEvent(logMessage);
}
Settings?.OnLogEvent(logMessage);
}
@@ -200,13 +145,16 @@ namespace EonaCat.Logger.Managers
public LogManager(LoggerSettings settings, string serverIp, int serverPort, string id = "EonaCatLogger")
{
if (string.IsNullOrEmpty(serverIp)) throw new ArgumentNullException(nameof(serverIp));
if (serverPort < 0) throw new ArgumentException("Server port must be zero or greater.");
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 SyslogServer(serverIp, serverPort)
};
{
new SyslogServer(serverIp, serverPort)
};
Id = id;
Settings = settings;
@@ -224,43 +172,26 @@ namespace EonaCat.Logger.Managers
private void SetupFileLogger(LoggerSettings settings = null, string logFolder = null, bool defaultPrefix = true)
{
if (settings == null)
{
// Create default loggingSettings
Settings = settings;
settings = Settings;
}
if (!settings.EnableFileLogging) return;
if (!settings.EnableFileLogging)
return;
if (logFolder != null)
{
Settings.FileLoggerOptions.LogDirectory = logFolder;
}
settings.FileLoggerOptions.LogDirectory = logFolder;
if (string.IsNullOrWhiteSpace(Settings.FileLoggerOptions.FileNamePrefix))
{
if (defaultPrefix)
{
Settings.FileLoggerOptions.FileNamePrefix = "EonaCat";
}
else
{
Settings.FileLoggerOptions.FileNamePrefix = string.Empty;
}
}
if (string.IsNullOrWhiteSpace(settings.FileLoggerOptions.FileNamePrefix))
settings.FileLoggerOptions.FileNamePrefix = defaultPrefix ? "EonaCat" : string.Empty;
}
private void SetupLogManager()
{
_token = _tokenSource.Token;
AppDomain.CurrentDomain.ProcessExit += ProcessExit;
Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);
_logDate = DateTime.Now;
Console.CancelKeyPress += Console_CancelKeyPress;
_logDate = DateTime.UtcNow;
}
void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
private void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
{
Dispose(true);
}
@@ -273,8 +204,8 @@ namespace EonaCat.Logger.Managers
private void StopLogging()
{
IsRunning = false;
Write(DateTime.Now, $"{DllInfo.ApplicationName} stopped.");
Task.Delay(500, _token);
Write(DateTime.UtcNow, $"{DllInfo.ApplicationName} stopped.");
Task.Delay(500, _tokenSource.Token);
}
public LogManager(string logFolder = null, bool defaultPrefix = true)
@@ -285,23 +216,21 @@ namespace EonaCat.Logger.Managers
public void Write(Exception exception, string module = null, string method = null, bool criticalException = false, bool? writeToConsole = null)
{
if (exception == null) return;
if (exception == null)
return;
Write(exception.FormatExceptionToMessage(module, method), criticalException ? ELogType.CRITICAL : ELogType.ERROR, writeToConsole);
}
public void Write(string message, ELogType logType = ELogType.INFO, bool? writeToConsole = null)
{
if (logType == ELogType.NONE)
{
return;
}
DateTime now = DateTime.Now;
DateTime now = DateTime.UtcNow;
if (!IsRunning)
{
StartNewLog();
}
Write(now, message, logType, writeToConsole);
}
@@ -309,14 +238,14 @@ namespace EonaCat.Logger.Managers
public void DeleteCurrentLogFile()
{
if (!string.IsNullOrWhiteSpace(CurrentLogFile))
{
File.Delete(CurrentLogFile);
}
}
void IDisposable.Dispose()
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
}

9
EonaCat.Logger/Managers/LoggerSettings.cs
View File

@@ -14,6 +14,11 @@ namespace EonaCat.Logger.Managers
public event LogDelegate OnLog;
public delegate void LogDelegate(EonaCatLogMessage message);
/// <summary>
/// Determines if we need to remove the prefix [EonaCatLogger] from each message (default: false)
/// </summary>
public bool RemoveMessagePrefix { get; set; }
/// <summary>
/// Header format. Provide a string that specifies how the preamble of each message should be structured. You can use variables including:
@@ -148,7 +153,7 @@ namespace EonaCat.Logger.Managers
}
/// <summary>
/// Set the origin of where the OnLog event was inititated
/// Set the origin of where the OnLog event was initiated
/// </summary>
public string LogOrigin { get; set; }
@@ -159,7 +164,7 @@ namespace EonaCat.Logger.Managers
private ColorSchema _colors = new ColorSchema();
private bool ConsoleExists()
private static bool ConsoleExists()
{
try
{