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

Updated

Browse Source
This commit is contained in:
EonaCat
2024-05-27 20:11:11 +02:00
parent c997b6c1a2
commit 005d91c199
19 changed files with 717 additions and 435 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
Testers/EonaCat.Logger.Test.Web/Logger.cs
View File

@@ -5,29 +5,52 @@ using EonaCat.Logger.Managers;
namespace EonaCat.Logger.Test.Web;
public static class Logger
public class Logger
{
private static LogManager LogManager;
public static ELogType MaxLogType { get; set; }
public static bool UseLocalTime { get; set; }
public static string LogFolder => Path.Combine(FileLoggerOptions.DefaultPath, "logs");
public static string CurrentLogFile => LogManager.CurrentLogFile;
public static bool IsDisabled { get; set; }
private LogManager _logManager;
public ELogType MaxLogType { get; set; }
public LoggerSettings LoggerSettings { get; }
public bool UseLocalTime { get; set; }
public string LogFolder { get; set; } = Path.Combine(FileLoggerOptions.DefaultPath, "logs");
public string CurrentLogFile => _logManager.CurrentLogFile;
public bool IsDisabled { get; set; }
public static void DeleteCurrentLogFile()
public Logger(string name = "EonaCatTestLogger", ELogType maxLogType = ELogType.INFO, bool useLocalTime = false, int maxFileSize = 20_000_000)
{
if (IsDisabled)
return;
UseLocalTime = useLocalTime;
MaxLogType = maxLogType;
LogManager.DeleteCurrentLogFile();
LoggerSettings = new LoggerSettings
{
Id = name,
MaxLogType = MaxLogType,
UseLocalTime = UseLocalTime,
FileLoggerOptions =
{
LogDirectory = LogFolder,
FileSizeLimit = maxFileSize,
UseLocalTime = UseLocalTime,
},
};
_logManager = new LogManager(LoggerSettings);
}
private static string ConvertToAbsolutePath(string path)
public void DeleteCurrentLogFile()
{
if (IsDisabled)
{
return;
}
_logManager.DeleteCurrentLogFile();
}
private string ConvertToAbsolutePath(string path)
{
return Path.IsPathRooted(path) ? path : Path.Combine(LogFolder, path);
}
public static async Task DownloadLogAsync(HttpContext context, string logName, long limit)
public async Task DownloadLogAsync(HttpContext context, string logName, long limit)
{
var logFileName = logName + ".log";
@@ -39,7 +62,9 @@ public static class Logger
response.Headers.ContentDisposition = "attachment;filename=" + logFileName;
if (limit > fS.Length || limit < 1)
{
limit = fS.Length;
}
var oFS = new OffsetStream(fS, 0, limit);
var request = context.Request;
@@ -81,43 +106,32 @@ public static class Logger
await oFS.CopyToAsync(stream).ConfigureAwait(false);
if (fS.Length > limit)
{
await stream.WriteAsync("\r\n####__EONACATLOGGER_TRUNCATED___####"u8.ToArray()).ConfigureAwait(false);
}
}
}
public static async Task LogAsync(string message, ELogType logType = ELogType.INFO, bool writeToConsole = true)
public async Task LogAsync(string message, ELogType logType = ELogType.INFO, bool writeToConsole = true)
{
if (IsDisabled)
{
return;
}
await LogManager.WriteAsync(message, logType, writeToConsole).ConfigureAwait(false);
await _logManager.WriteAsync(message, logType, writeToConsole).ConfigureAwait(false);
}
public static async Task LogAsync(Exception exception, string message = "", bool writeToConsole = true)
public async Task LogAsync(Exception exception, string message = "", bool writeToConsole = true)
{
if (IsDisabled)
{
return;
}
if (ELogType.ERROR <= MaxLogType)
{
await LogManager.WriteAsync(exception, message, writeToConsole: writeToConsole).ConfigureAwait(false);
await _logManager.WriteAsync(exception, message, writeToConsole: writeToConsole).ConfigureAwait(false);
}
}
public static void Configure()
{
var loggerSettings = new LoggerSettings
{
Id = "EonaCatTestLogger",
MaxLogType = ELogType.INFO,
UseLocalTime = UseLocalTime,
FileLoggerOptions =
{
LogDirectory = LogFolder,
FileSizeLimit = 20_000_000, // 20 MB,
UseLocalTime = UseLocalTime
}
};
LogManager = new LogManager(loggerSettings);
}
}

79
Testers/EonaCat.Logger.Test.Web/Program.cs
View File

@@ -1,6 +1,7 @@
using EonaCat.Logger;
using EonaCat.Logger.EonaCatCoreLogger;
using EonaCat.Logger.EonaCatCoreLogger.Extensions;
using EonaCat.Logger.EonaCatCoreLogger.Models;
using EonaCat.Logger.Managers;
using EonaCat.Logger.Test.Web;
using EonaCat.Web.RateLimiter;
@@ -8,11 +9,21 @@ using EonaCat.Web.RateLimiter.Endpoints.Extensions;
using EonaCat.Web.Tracer.Extensions;
var builder = WebApplication.CreateBuilder(args);
int onLogCounter = 0;
var defaultColor = Console.ForegroundColor;
// Add services to the container.
Logger.UseLocalTime = true;
Logger.MaxLogType = ELogType.TRACE;
Logger.Configure();
Logger logger = new Logger();
logger.UseLocalTime = true;
logger.MaxLogType = ELogType.TRACE;
logger.LoggerSettings.OnLog += LoggerSettings_OnLog;
void LoggerSettings_OnLog(EonaCatLogMessage message)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"LogCounter: {++onLogCounter} {message}");
Console.ForegroundColor = defaultColor;
}
var options = new FileLoggerOptions();
options.MaxRolloverFiles = 5;
@@ -124,11 +135,11 @@ void RunLoggingExceptionTests()
}
}
Task.Run(RunWebLoggerTests).ConfigureAwait(false);
Task.Run(RunWebLoggingTests).ConfigureAwait(false);
Task.Run(RunLoggingTests).ConfigureAwait(false);
Task.Run(RunLoggingExceptionTests).ConfigureAwait(false);
Task.Run(RunWebLoggingExceptionTests).ConfigureAwait(false);
await Task.Run(RunWebLoggerTestsAsync).ConfigureAwait(false);
await Task.Run(RunWebLoggingTests).ConfigureAwait(false);
await Task.Run(RunLoggingTestsAsync).ConfigureAwait(false);
await Task.Run(RunLoggingExceptionTests).ConfigureAwait(false);
await Task.Run(RunWebLoggingExceptionTests).ConfigureAwait(false);
void RunWebLoggingExceptionTests()
{
@@ -155,12 +166,15 @@ void RunWebLoggingExceptionTests()
async void RunWebLoggingTests()
{
if (!Directory.Exists(Logger.LogFolder)) Directory.CreateDirectory(Logger.LogFolder);
if (!Directory.Exists(logger.LogFolder))
{
Directory.CreateDirectory(logger.LogFolder);
}
for (var i = 0; i < 9000000; i++)
{
app.Logger.LogInformation($"web-test {i}");
using (var file = new StreamWriter(Path.Combine(Logger.LogFolder, "test.log"), true))
using (var file = new StreamWriter(Path.Combine(logger.LogFolder, "test.log"), true))
{
await file.WriteAsync($"WebLogged: {i}{Environment.NewLine}").ConfigureAwait(false);
}
@@ -169,7 +183,7 @@ async void RunWebLoggingTests()
}
}
void RunLoggingTests()
async Task RunLoggingTestsAsync()
{
var loggerSettings = new LoggerSettings();
loggerSettings.UseLocalTime = true;
@@ -182,38 +196,37 @@ void RunLoggingTests()
for (var i = 0; i < 9000000; i++)
{
logger.WriteAsync($"test to file {i} INFO").ConfigureAwait(false);
logger.WriteAsync($"test to file {i} CRITICAL", ELogType.CRITICAL).ConfigureAwait(false);
logger.WriteAsync($"test to file {i} DEBUG", ELogType.DEBUG).ConfigureAwait(false);
logger.WriteAsync($"test to file {i} ERROR", ELogType.ERROR).ConfigureAwait(false);
logger.WriteAsync($"test to file {i} TRACE", ELogType.TRACE).ConfigureAwait(false);
logger.WriteAsync($"test to file {i} TRAFFIC", ELogType.TRAFFIC).ConfigureAwait(false);
logger.WriteAsync($"test to file {i} WARNING", ELogType.WARNING).ConfigureAwait(false);
logger.WriteAsync($"test to file {i} NONE", ELogType.NONE).ConfigureAwait(false);
await logger.WriteAsync($"test to file {i} INFO").ConfigureAwait(false);
await logger.WriteAsync($"test to file {i} CRITICAL", ELogType.CRITICAL).ConfigureAwait(false);
await logger.WriteAsync($"test to file {i} DEBUG", ELogType.DEBUG).ConfigureAwait(false);
await logger.WriteAsync($"test to file {i} ERROR", ELogType.ERROR).ConfigureAwait(false);
await logger.WriteAsync($"test to file {i} TRACE", ELogType.TRACE).ConfigureAwait(false);
await logger.WriteAsync($"test to file {i} TRAFFIC", ELogType.TRAFFIC).ConfigureAwait(false);
await logger.WriteAsync($"test to file {i} WARNING", ELogType.WARNING).ConfigureAwait(false);
await logger.WriteAsync($"test to file {i} NONE", ELogType.NONE).ConfigureAwait(false);
Console.WriteLine($"Logged: {i}");
Task.Delay(1);
await Task.Delay(1).ConfigureAwait(false);
}
}
void RunWebLoggerTests()
async Task RunWebLoggerTestsAsync()
{
var i = 0;
while (true)
{
i++;
Task.Run(() =>
await Task.Run(async () =>
{
Logger.LogAsync($"test via logger {i} INFO");
Logger.LogAsync($"test via logger {i} CRITICAL", ELogType.CRITICAL);
Logger.LogAsync($"test via logger {i} DEBUG", ELogType.DEBUG);
Logger.LogAsync($"test via logger {i} ERROR", ELogType.ERROR);
Logger.LogAsync($"test via logger {i} TRACE", ELogType.TRACE);
Logger.LogAsync($"test via logger {i} TRAFFIC", ELogType.TRAFFIC);
Logger.LogAsync($"test via logger {i} WARNING", ELogType.WARNING);
Logger.LogAsync($"test via logger {i} NONE", ELogType.NONE);
});
Console.WriteLine($"Logger: {i}");
Task.Delay(1);
await logger.LogAsync($"test via logger {i} INFO").ConfigureAwait(false);
await logger.LogAsync($"test via logger {i} CRITICAL", ELogType.CRITICAL).ConfigureAwait(false);
await logger.LogAsync($"test via logger {i} DEBUG", ELogType.DEBUG).ConfigureAwait(false);
await logger.LogAsync($"test via logger {i} ERROR", ELogType.ERROR).ConfigureAwait(false);
await logger.LogAsync($"test via logger {i} TRACE", ELogType.TRACE).ConfigureAwait(false);
await logger.LogAsync($"test via logger {i} TRAFFIC", ELogType.TRAFFIC).ConfigureAwait(false);
await logger.LogAsync($"test via logger {i} WARNING", ELogType.WARNING).ConfigureAwait(false);
await logger.LogAsync($"test via logger {i} NONE", ELogType.NONE).ConfigureAwait(false);
}).ConfigureAwait(false);
await Task.Delay(1).ConfigureAwait(false);
}
}