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

Updated

Browse Source
This commit is contained in:
jsaey
2024-04-25 08:26:20 +02:00
parent 8f8dbfb1c4
commit 25b959f75a
3 changed files with 107 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
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>
<Version>1.2.4</Version> <Version>1.2.5</Version>
<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>
@@ -22,7 +22,19 @@
<Title>EonaCat.Logger</Title> <Title>EonaCat.Logger</Title>
<RepositoryType>git</RepositoryType> <RepositoryType>git</RepositoryType>
</PropertyGroup> </PropertyGroup>
<ItemGroup>
<PropertyGroup>
<EVRevisionFormat>1.0.0.0+{chash:10}.{c:ymd}</EVRevisionFormat>
<EVDefault>true</EVDefault>
<EVInfo>true</EVInfo>
<EVTagMatch>v[0-9]*</EVTagMatch>
<EVRemoveTagV>true</EVRemoveTagV>
<EVVcs>git</EVVcs>
<EVCheckAllAttributes>true</EVCheckAllAttributes>
<EVShowRevision>true</EVShowRevision>
</PropertyGroup>
<ItemGroup>
<None Remove="icon.png" /> <None Remove="icon.png" />
<None Include="..\LICENSE"> <None Include="..\LICENSE">
<Pack>True</Pack> <Pack>True</Pack>
@@ -39,7 +51,11 @@
</None> </None>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<PackageReference Include="EonaCat.Json" Version="1.0.3" /> <PackageReference Include="EonaCat.Json" Version="1.0.5" />
<PackageReference Include="EonaCat.Versioning" Version="1.0.5">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" /> <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
<PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" /> <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
<PackageReference Include="System.Net.Http" Version="4.3.4" /> <PackageReference Include="System.Net.Http" Version="4.3.4" />

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

@@ -1,14 +1,9 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net; using System.Net;
using System.Net.Http;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
using System.Xml.Linq;
using EonaCat.Json; using EonaCat.Json;
using EonaCat.Json.Linq;
using EonaCat.Logger.Extensions; using EonaCat.Logger.Extensions;
using EonaCat.Logger.GrayLog; using EonaCat.Logger.GrayLog;
using EonaCat.Logger.Splunk.Models; using EonaCat.Logger.Splunk.Models;
@@ -35,36 +30,21 @@ namespace EonaCat.Logger.Managers
if (string.IsNullOrWhiteSpace(currentMessage)) if (string.IsNullOrWhiteSpace(currentMessage))
return currentMessage; return currentMessage;
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder(settings?.HeaderFormat ?? "[EonaCatLogger]");
sb.Append(settings?.HeaderFormat ?? "[EonaCatLogger]"); sb.Replace("{ts}", dateTime.ToString(settings?.TimestampFormat ?? "yyyy-MM-dd HH:mm:ss") + " " + (settings?.UseLocalTime ?? false ? "[LOCAL]" : "[UTC]"))
.Replace("{host}", $"[Host:{Dns.GetHostName()}]")
.Replace("{thread}", $"[ThreadId:{Environment.CurrentManagedThreadId}]")
.Replace("{sev}", $"[{logType}]");
if (settings != null) if (!settings?.RemoveMessagePrefix ?? false && !currentMessage.Contains("[EonaCatLogger]"))
{ sb.Insert(0, "[EonaCatLogger] ");
if (sb.ToString().Contains("{ts}"))
sb.Replace("{ts}", dateTime.ToString(settings.TimestampFormat) + " " + (settings.UseLocalTime ? "[LOCAL]" : "[UTC]"));
if (sb.ToString().Contains("{host}")) sb.Append(" ").Append(currentMessage);
sb.Replace("{host}", $"[Host:{Dns.GetHostName()}]");
if (sb.ToString().Contains("{thread}"))
sb.Replace("{thread}", $"[ThreadId:{Environment.CurrentManagedThreadId.ToString()}]");
if (sb.ToString().Contains("{sev}"))
sb.Replace("{sev}", $"[{logType.ToString()}]");
if (!settings.RemoveMessagePrefix && !currentMessage.Contains("[EonaCatLogger]"))
sb.Insert(0, "[EonaCatLogger] ");
}
sb.Append(" ");
sb.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))
@@ -123,20 +103,15 @@ namespace EonaCat.Logger.Managers
} }
} }
internal static void SendToFile(ILogger logger, LoggerSettings settings, ELogType logType, string message) internal static async Task SendToFile(ILogger logger, LoggerSettings settings, ELogType logType, string message)
{ {
if (logger == null || settings == null || !settings.EnableFileLogging || string.IsNullOrWhiteSpace(message)) if (logger == null || settings == null || !settings.EnableFileLogging || string.IsNullOrWhiteSpace(message))
return; return;
LogLevel logLevel = logType.ToLogLevel(); LogLevel logLevel = logType.ToLogLevel();
if (logLevel >= settings.MaxLogType.ToLogLevel()) // Filter out log levels if (logLevel >= settings.MaxLogType.ToLogLevel())
Log(logger, logLevel, message); await Task.Run(() => logger.Log(logLevel, message));
}
private static void Log(ILogger logger, LogLevel logLevel, string message)
{
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)
@@ -151,35 +126,25 @@ namespace EonaCat.Logger.Managers
foreach (var splunkServer in settings.SplunkServers) foreach (var splunkServer in settings.SplunkServers)
{ {
if (!splunkServer.HasHecUrl) if (!splunkServer.HasHecUrl || !splunkServer.HasHecToken)
{ {
Console.WriteLine("Splunk server HecUrl not specified, skipping splunkServer"); OnException?.Invoke(null, new ErrorMessage { Message = $"Splunk server HecUrl or HecToken not specified, skipping splunkServer '{splunkServer.SplunkHecUrl}'" });
continue; continue;
} }
if (!splunkServer.HasHecToken) try
{ {
OnException?.Invoke(null, new ErrorMessage { Message = $"Splunk server HecToken not specified, skipping splunkServer '{splunkServer.SplunkHecUrl}'" }); var response = await splunkServer.SendAsync(splunkPayload);
Console.WriteLine($"Splunk server HecToken not specified, skipping splunkServer '{splunkServer.SplunkHecUrl}'");
continue; if (!response.IsSuccessStatusCode)
{
OnException?.Invoke(null, new ErrorMessage { Message = $"Failed to send log to Splunk '{splunkServer.SplunkHecUrl}'. Status code: {response.StatusCode}" });
}
} }
catch (Exception exception)
await Task.Run(async () =>
{ {
try OnException?.Invoke(null, new ErrorMessage { Exception = exception, Message = $"Error while logging to Splunk Server '{splunkServer.SplunkHecUrl}': {exception.Message}" });
{ }
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}" });
}
}
catch (Exception exception)
{
OnException?.Invoke(null, new ErrorMessage { Exception = exception, Message = $"Error while logging to Splunk Server '{splunkServer.SplunkHecUrl}': {exception.Message}" });
}
});
} }
} }
@@ -203,36 +168,28 @@ namespace EonaCat.Logger.Managers
if (settings == null || !sendToGrayLogServer || string.IsNullOrWhiteSpace(message)) if (settings == null || !sendToGrayLogServer || string.IsNullOrWhiteSpace(message))
return; return;
if (settings.GrayLogServers == null || !settings.GrayLogServers.Any()) foreach (var grayLogServer in settings.GrayLogServers ?? new List<GrayLogServer> { new GrayLogServer("127.0.0.1", 12201) })
{ {
settings.GrayLogServers = new List<GrayLogServer> { new GrayLogServer("127.0.0.1", 12201) }; try
}
foreach (var grayLogServer in settings.GrayLogServers)
{
await Task.Run(async () =>
{ {
try var gelfMessage = new
{ {
var gelfMessage = new version,
{ host = Environment.MachineName,
version, short_message = message,
host = Environment.MachineName, level = logLevel.ToGrayLogLevel(),
short_message = message, facility,
level = logLevel.ToGrayLogLevel(), source,
facility, timestamp = DateTime.UtcNow.ToUnixTimestamp(),
source, };
timestamp = DateTime.UtcNow.ToUnixTimestamp(),
};
var messageBytes = Encoding.UTF8.GetBytes(JsonHelper.ToJson(gelfMessage)); var messageBytes = Encoding.UTF8.GetBytes(JsonHelper.ToJson(gelfMessage));
await grayLogServer.Udp.SendAsync(messageBytes, messageBytes.Length, new IPEndPoint(IPAddress.Parse(grayLogServer.Hostname), grayLogServer.Port)); await grayLogServer.Udp.SendAsync(messageBytes, messageBytes.Length, new IPEndPoint(IPAddress.Parse(grayLogServer.Hostname), grayLogServer.Port));
} }
catch (Exception exception) catch (Exception exception)
{ {
OnException?.Invoke(null, new ErrorMessage { Exception = exception, Message = $"Error while logging to GrayLog Server '{grayLogServer.Hostname}': {exception.Message}" }); OnException?.Invoke(null, new ErrorMessage { Exception = exception, Message = $"Error while logging to GrayLog Server '{grayLogServer.Hostname}': {exception.Message}" });
} }
});
} }
} }
@@ -241,38 +198,29 @@ namespace EonaCat.Logger.Managers
if (settings == null || !sendToSyslogServers || string.IsNullOrWhiteSpace(message)) if (settings == null || !sendToSyslogServers || string.IsNullOrWhiteSpace(message))
return; return;
if (settings.SysLogServers == null || !settings.SysLogServers.Any()) foreach (var server in settings.SysLogServers ?? new List<SyslogServer> { new SyslogServer("127.0.0.1", 514) })
{ {
settings.SysLogServers = new List<SyslogServer> { new SyslogServer("127.0.0.1", 514) }; try
}
byte[] data = Encoding.UTF8.GetBytes(message);
foreach (SyslogServer server in settings.SysLogServers)
{
await Task.Run(() =>
{ {
try if (string.IsNullOrWhiteSpace(server.Hostname))
{ {
if (string.IsNullOrWhiteSpace(server.Hostname)) OnException?.Invoke(null, new ErrorMessage { Message = "Server hostname not specified, skipping SysLog Server" });
{ continue;
OnException?.Invoke(null, new ErrorMessage { Message = "Server hostname not specified, skipping SysLog Server" });
return;
}
if (server.Port < 0)
{
OnException?.Invoke(null, new ErrorMessage { Message = "Server port must be zero or greater, skipping SysLog Server" });
return;
}
server.Udp.Send(data, data.Length);
} }
catch (Exception exception)
if (server.Port < 0)
{ {
OnException?.Invoke(null, new ErrorMessage { Exception = exception, Message = $"Error while logging to SysLog Server '{server.Hostname}': {exception.Message}" }); OnException?.Invoke(null, new ErrorMessage { Message = "Server port must be zero or greater, skipping SysLog Server" });
continue;
} }
});
byte[] data = Encoding.UTF8.GetBytes(message);
await server.Udp.SendAsync(data, data.Length, new IPEndPoint(IPAddress.Parse(server.Hostname), server.Port));
}
catch (Exception exception)
{
OnException?.Invoke(null, new ErrorMessage { Exception = exception, Message = $"Error while logging to SysLog Server '{server.Hostname}': {exception.Message}" });
}
} }
} }
} }

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

@@ -10,7 +10,6 @@ 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 System.Text;
namespace EonaCat.Logger.Managers namespace EonaCat.Logger.Managers
{ {
@@ -65,10 +64,14 @@ namespace EonaCat.Logger.Managers
public async Task StartNewLogAsync() public async Task StartNewLogAsync()
{ {
if (_tokenSource.IsCancellationRequested) if (_tokenSource.IsCancellationRequested)
{
return; return;
}
if (IsRunning && CurrentDateTme.Date > _logDate.Date) if (IsRunning && CurrentDateTme.Date > _logDate.Date)
{
await StopLoggingAsync().ConfigureAwait(false); await StopLoggingAsync().ConfigureAwait(false);
}
IsRunning = true; IsRunning = true;
@@ -103,45 +106,42 @@ namespace EonaCat.Logger.Managers
Logger = LoggerFactory.CreateLogger(Settings.Id); Logger = LoggerFactory.CreateLogger(Settings.Id);
} }
private void 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") 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 || (int)logType >= (int)Settings.MaxLogType) if (string.IsNullOrEmpty(message) || logType == ELogType.NONE || (int)logType >= (int)Settings.MaxLogType)
{
return; return;
}
var messageWithHeader = LogHelper.FormatMessageWithHeader(Settings, logType, message, dateTime); string messageWithHeader = LogHelper.FormatMessageWithHeader(Settings, logType, message, dateTime);
bool writeToConsoleValue = writeToConsole ?? Settings.EnableConsole;
bool sendToSyslogServersValue = sendToSyslogServers ?? Settings.SendToSyslogServers;
bool sendToSplunkServersValue = sendToSplunkServers ?? Settings.SendToSplunkServers;
bool sendToGrayLogServersValue = sendToGrayLogServers ?? Settings.SendToGrayLogServers;
writeToConsole ??= Settings.EnableConsole; if (writeToConsoleValue)
if (writeToConsole.Value)
{ {
LogHelper.SendToConsole(Settings, logType, messageWithHeader, true); LogHelper.SendToConsole(Settings, logType, messageWithHeader, true);
} }
Task.Run(() => { LogHelper.SendToFile(Logger, Settings, logType, message); }); if (sendToSyslogServersValue || sendToSplunkServersValue || sendToGrayLogServersValue)
sendToSyslogServers ??= Settings.SendToSyslogServers;
if (sendToSyslogServers.Value)
{ {
Task.Run(async () => await Task.Run(async () =>
{ {
await LogHelper.SendToSysLogServersAsync(Settings, messageWithHeader, true); if (sendToSyslogServersValue)
}); {
} await LogHelper.SendToSysLogServersAsync(Settings, messageWithHeader, true);
}
sendToSplunkServers ??= Settings.SendToSplunkServers; if (sendToSplunkServersValue)
if (sendToSplunkServers.Value) {
{ await LogHelper.SendToSplunkServersAsync(Settings, customSplunkSourceType ?? logType.ToString(), messageWithHeader, true);
Task.Run(async () => }
{
await LogHelper.SendToSplunkServersAsync(Settings, customSplunkSourceType ?? logType.ToString(), messageWithHeader, true);
});
}
sendToGrayLogServers ??= Settings.SendToGrayLogServers; if (sendToGrayLogServersValue)
if (sendToGrayLogServers.Value) {
{ await LogHelper.SendToGrayLogServersAsync(Settings, messageWithHeader, logType, grayLogFacility, grayLogSource, true, grayLogVersion);
Task.Run(async () => }
{
await LogHelper.SendToGrayLogServersAsync(Settings, messageWithHeader, logType, grayLogFacility, grayLogSource, true, grayLogVersion);
}); });
} }
@@ -155,9 +155,8 @@ namespace EonaCat.Logger.Managers
Settings.OnLogEvent(logMessage); Settings.OnLogEvent(logMessage);
} }
public void Reset() => Settings.ResetLogEvent(); public void Reset() => Settings.ResetLogEvent();
public LogManager(LoggerSettings settings, string serverIp, int serverPort) public LogManager(LoggerSettings settings, string serverIp, int serverPort)
{ {
@@ -221,10 +220,10 @@ namespace EonaCat.Logger.Managers
Dispose(); Dispose();
} }
private Task StopLoggingAsync() private async Task<Task> StopLoggingAsync()
{ {
IsRunning = false; IsRunning = false;
InternalWriteAsync(CurrentDateTme, $"{DllInfo.ApplicationName} stopped."); await InternalWriteAsync(CurrentDateTme, $"{DllInfo.ApplicationName} stopped.").ConfigureAwait(false);
return Task.Delay(500); return Task.Delay(500);
} }