From 1f4f51adc58dc5fbbae3251ad0d2debbc9cbd67b Mon Sep 17 00:00:00 2001 From: EonaCat Date: Sat, 27 Apr 2024 13:55:49 +0200 Subject: [PATCH] Updated --- .../EonaCatCoreLogger/FileLoggerProvider.cs | 230 +++++++++--------- .../Internal/BatchingLoggerProvider.cs | 59 +++-- EonaCat.Logger/Managers/ILogManager.cs | 9 +- EonaCat.Logger/Managers/LogHelper.cs | 10 + EonaCat.Logger/Managers/LogManager.cs | 55 +++-- Testers/EonaCat.Logger.Test.Web/Logger.cs | 8 +- Testers/EonaCat.Logger.Test.Web/Program.cs | 70 +++--- 7 files changed, 249 insertions(+), 192 deletions(-) diff --git a/EonaCat.Logger/EonaCatCoreLogger/FileLoggerProvider.cs b/EonaCat.Logger/EonaCatCoreLogger/FileLoggerProvider.cs index c2a2f24..5c572d3 100644 --- a/EonaCat.Logger/EonaCatCoreLogger/FileLoggerProvider.cs +++ b/EonaCat.Logger/EonaCatCoreLogger/FileLoggerProvider.cs @@ -73,34 +73,59 @@ public class FileLoggerProvider : BatchingLoggerProvider protected override async Task WriteMessagesAsync(IEnumerable messages, CancellationToken cancellationToken) { - Directory.CreateDirectory(_path); - - foreach (var group in messages.GroupBy(GetGrouping)) + if (IsWriting) { - LogFile = GetFullName(group.Key); - var fileInfo = new FileInfo(LogFile); - var currentMessages = string.Join(string.Empty, group.Select(item => item.Message)); - if (!_buffer.TryAdd(LogFile, currentMessages)) - { - _buffer[LogFile] += currentMessages; - } + return; + } - await MoveRolloverLogFilesAsync(fileInfo, cancellationToken).ConfigureAwait(false); + IsWriting = true; - if (await TryWriteToFileAsync(cancellationToken)) - { - // Clear buffer on success - _buffer.Clear(); - } - else if (await WriteToTempFileAsync(cancellationToken)) - { - // Fallback to temp file - } + try + { + Directory.CreateDirectory(_path); - DeleteOldLogFiles(); + foreach (var group in messages.GroupBy(GetGrouping)) + { + LogFile = GetFullName(group.Key); + var currentMessages = string.Join(string.Empty, group.Select(item => item.Message)); + if (!_buffer.TryAdd(LogFile, currentMessages)) + { + _buffer[LogFile] += currentMessages; + } + + // Check file size + FileInfo fileInfo = new FileInfo(LogFile); + if (fileInfo.Exists && fileInfo.Length >= _maxFileSize) + { + // Roll over the log file + await RollOverLogFile().ConfigureAwait(false); + } + + if (await TryWriteToFileAsync(cancellationToken)) + { + // Clear buffer on success + _buffer.Clear(); + } + else if (await WriteToTempFileAsync(cancellationToken)) + { + // Fallback to temp file + } + + DeleteOldLogFiles(); + } + } + catch (Exception exception) + { + OnError?.Invoke(this, new ErrorMessage { Exception = exception, Message = "Cannot write to file"}); + } + finally + { + IsWriting = false; } } + public bool IsWriting { get; set; } + private async Task TryWriteToFileAsync(CancellationToken cancellationToken) { if (!_buffer.ContainsKey(LogFile)) return true; @@ -116,10 +141,9 @@ public class FileLoggerProvider : BatchingLoggerProvider { await file.WriteAsync(_buffer[LogFile]).ConfigureAwait(false); } - completed = true; _buffer.TryRemove(LogFile, out _); - return true; // Success + return true; } catch (Exception) { @@ -128,7 +152,7 @@ public class FileLoggerProvider : BatchingLoggerProvider if (tries >= _maxTries) { OnError?.Invoke(this, new ErrorMessage { Message = "Cannot write to log folder"}); - return false; // Failure after retries + return false; } } } @@ -178,104 +202,82 @@ public class FileLoggerProvider : BatchingLoggerProvider return (message.Timestamp.Year, message.Timestamp.Month, message.Timestamp.Day); } - private static void MoveFile(string copyFromPath, string copyToPath) - { - var origin = new FileInfo(copyFromPath); - origin.MoveTo(copyToPath); + private readonly object lockObj = new object(); - var destination = new FileInfo(copyToPath); - destination.CreationTime = origin.CreationTime; - destination.LastWriteTime = origin.LastWriteTime; - destination.LastAccessTime = origin.LastAccessTime; + private async Task RollOverLogFile() + { + lock (lockObj) + { + try + { + string directoryPath = Path.GetDirectoryName(LogFile); + string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(LogFile); + string fileExtension = Path.GetExtension(LogFile); + + // Rename existing files + for (int i = _maxRolloverFiles - 1; i >= 1; i--) + { + string currentFilePath = Path.Combine(directoryPath, $"{fileNameWithoutExtension}.{i}{fileExtension}"); + string newFilePath = Path.Combine(directoryPath, $"{fileNameWithoutExtension}.{(i + 1)}{fileExtension}"); + + if (File.Exists(currentFilePath)) + { + if (File.Exists(newFilePath)) + { + File.Delete(newFilePath); + } + File.Move(currentFilePath, newFilePath); + } + + if (i != 1) + { + continue; + } + + currentFilePath = Path.Combine(directoryPath, $"{fileNameWithoutExtension}{fileExtension}"); + newFilePath = Path.Combine(directoryPath, $"{fileNameWithoutExtension}.{i}{fileExtension}"); + File.Move(currentFilePath, newFilePath); + } + + // Rename current log file + var rolloverFilePath = Path.Combine(directoryPath, $"{fileNameWithoutExtension}.1{fileExtension}"); + + // Write end message and start processing in background + Task.Run(async () => + { + await WriteEndMessageAsync(rolloverFilePath).ConfigureAwait(false); + await ProcessAsync().ConfigureAwait(false); + }); + } + catch (Exception ex) + { + // Log or handle the exception + Console.WriteLine($"Error occurred during log file rollover: {ex.Message}"); + } + } } - private async Task MoveRolloverLogFilesAsync(FileInfo fileInfo, CancellationToken cancellationToken) + private async Task WriteEndMessageAsync(string logFilePath) + { + var stopMessage = LogHelper.GetStopMessage(); + stopMessage = LogHelper.FormatMessageWithHeader(LoggerSettings, ELogType.INFO, stopMessage, CurrentDateTme); + + using (var file = new StreamWriter(logFilePath, true)) + { + await file.WriteAsync(stopMessage).ConfigureAwait(false); + } + } + + private async Task ProcessAsync() { try { - if (_maxFileSize > 0 && fileInfo.Exists && fileInfo.Length > _maxFileSize) - { - if (_maxRolloverFiles > 0 && _rollOverCount >= 0) - { - if (_rollOverCount < _maxRolloverFiles) - { - var rollOverFile = LogFile.Replace(".log", $"_{++_rollOverCount}.log"); - if (File.Exists(rollOverFile)) - { - File.Delete(rollOverFile); - } - fileInfo.CopyTo(rollOverFile); - File.WriteAllText(LogFile, string.Empty); - } - else - { - lock (_rollOverLock) - { - _rollingOver = true; - MoveRolloverLogFiles(); - _rollingOver = false; - } - } - } - } - - while (_rollingOver) - { - await Task.Delay(100, cancellationToken).ConfigureAwait(false); - } + await WriteStartMessage().ConfigureAwait(false); } - catch (Exception exception) + catch (Exception ex) { - OnError?.Invoke(this, new ErrorMessage { Message = "Cannot rollover files" }); - } - } - - private object _rollOverLock { get; set; } = new object(); - - /// - /// Rollover logFiles - /// - private void MoveRolloverLogFiles() - { - if (_maxRolloverFiles > 0 && _rollOverCount >= 0) - { - if (_rollOverCount >= _maxRolloverFiles) - { - var maxRollover = _rollOverCount; - bool hasPrefix = !string.IsNullOrWhiteSpace(_fileNamePrefix); - IEnumerable files; - if (hasPrefix) - { - files = new DirectoryInfo(_path).GetFiles(_fileNamePrefix + "*").OrderBy(x => x.CreationTime); - } - else - { - files = new DirectoryInfo(_path).GetFiles("*").OrderBy(x => x.CreationTime); - } - - for (int i = files.Count() - 1; i >= 0; i--) - { - var currentFile = files.ElementAt(i); - if (i == 0) - { - // Temporary move first file - var newFilename2 = Path.GetFileName(currentFile.FullName).Replace($".log", $"_{i + 1}.log"); - MoveFile(currentFile.FullName, $@"{Path.GetDirectoryName(currentFile.FullName)}\{newFilename2}"); - continue; - } - - if (i == files.Count() - 1) - { - // Delete the last file - File.Delete(currentFile.FullName); - continue; - } - - var newFilename = Path.GetFileName(currentFile.FullName).Replace($"_{i}.log", $"_{i + 1}.log"); - MoveFile(currentFile.FullName, $@"{Path.GetDirectoryName(currentFile.FullName)}\{newFilename}"); - } - _rollOverCount = 0; - } + // Log or handle the exception + Console.WriteLine($"Error occurred during log file rollover: {ex.Message}"); } } diff --git a/EonaCat.Logger/EonaCatCoreLogger/Internal/BatchingLoggerProvider.cs b/EonaCat.Logger/EonaCatCoreLogger/Internal/BatchingLoggerProvider.cs index 1854e61..1ece0f4 100644 --- a/EonaCat.Logger/EonaCatCoreLogger/Internal/BatchingLoggerProvider.cs +++ b/EonaCat.Logger/EonaCatCoreLogger/Internal/BatchingLoggerProvider.cs @@ -21,6 +21,8 @@ public abstract class BatchingLoggerProvider : ILoggerProvider, IDisposable private ConcurrentQueue _messageQueue; private Task _outputTask; + private object _writeLock = new object(); + private bool _isDisposing; protected BatchingLoggerProvider(IOptions options) { @@ -33,7 +35,7 @@ public abstract class BatchingLoggerProvider : ILoggerProvider, IDisposable if (options.Value is FileLoggerOptions fileLoggerOptions) UseLocalTime = fileLoggerOptions.UseLocalTime; _batchSize = loggerOptions.BatchSize; - Start(); + StartAsync().ConfigureAwait(false); } protected DateTimeOffset CurrentDateTimeOffset => UseLocalTime ? DateTimeOffset.Now : DateTimeOffset.UtcNow; @@ -59,8 +61,12 @@ public abstract class BatchingLoggerProvider : ILoggerProvider, IDisposable public void Dispose() { - while (!_messageQueue.IsEmpty) Task.Delay(10); + while (!_messageQueue.IsEmpty) + { + Task.Delay(10); + } + _isDisposing = true; StopAsync().GetAwaiter().GetResult(); GC.SuppressFinalize(this); } @@ -71,14 +77,8 @@ public abstract class BatchingLoggerProvider : ILoggerProvider, IDisposable } protected abstract Task WriteMessagesAsync(IEnumerable messages, CancellationToken token); - private async Task ProcessLogQueueAsync(object state) { - var startupMessage = $"{DllInfo.ApplicationName} started.{Environment.NewLine}"; - startupMessage = - LogHelper.FormatMessageWithHeader(LoggerSettings, ELogType.INFO, startupMessage, CurrentDateTme); - AddMessage(DateTimeOffset.Now, startupMessage); - while (!_cancellationTokenSource.IsCancellationRequested) { var limit = _batchSize <= 0 ? int.MaxValue : _batchSize; @@ -89,44 +89,57 @@ public abstract class BatchingLoggerProvider : ILoggerProvider, IDisposable } if (_currentBatch.Count > 0) + { try { - await WriteMessagesAsync(_currentBatch, _cancellationTokenSource.Token).ConfigureAwait(false); - _currentBatch.Clear(); + if (_isDisposing) + { + return; + } + + lock (_writeLock) + { + WriteMessagesAsync(_currentBatch, _cancellationTokenSource.Token).ConfigureAwait(false); + _currentBatch.Clear(); + } } catch { // ignored } - + } Thread.Sleep(10); } } + protected async Task WriteStartMessage() + { + var message = LogHelper.GetStartupMessage(); + await WriteMessagesAsync(new List { new LogMessage() { Message = message, Timestamp = CurrentDateTimeOffset } }, _cancellationTokenSource.Token).ConfigureAwait(false); + } + + private async Task WriteStopMessage() + { + var message = LogHelper.GetStopMessage(); + await WriteMessagesAsync(new List { new LogMessage() { Message = message, Timestamp = CurrentDateTimeOffset } }, _cancellationTokenSource.Token).ConfigureAwait(false); + } + internal void AddMessage(DateTimeOffset timestamp, string message) { _messageQueue.Enqueue(new LogMessage { Message = message, Timestamp = timestamp }); } - private void Start() + private Task StartAsync() { IsStarted = true; _messageQueue = new ConcurrentQueue(); - _cancellationTokenSource = new CancellationTokenSource(); + _outputTask = Task.Factory.StartNew( ProcessLogQueueAsync, null, - TaskCreationOptions.LongRunning).ContinueWith(async x => - { - var stopMessage = $"{DllInfo.ApplicationName} stopped.{Environment.NewLine}"; - stopMessage = LogHelper.FormatMessageWithHeader(LoggerSettings, ELogType.INFO, stopMessage, CurrentDateTme); - await WriteMessagesAsync( - new List(new List - { new() { Message = stopMessage, Timestamp = CurrentDateTme } }), - _cancellationTokenSource.Token) - .ConfigureAwait(false); - }); + TaskCreationOptions.LongRunning); + return Task.CompletedTask; } private async Task StopAsync() diff --git a/EonaCat.Logger/Managers/ILogManager.cs b/EonaCat.Logger/Managers/ILogManager.cs index f9124f0..b3576d9 100644 --- a/EonaCat.Logger/Managers/ILogManager.cs +++ b/EonaCat.Logger/Managers/ILogManager.cs @@ -1,4 +1,5 @@ using System; +using System.Threading.Tasks; namespace EonaCat.Logger.Managers; // This file is part of the EonaCat project(s) which is released under the Apache License. @@ -6,13 +7,13 @@ namespace EonaCat.Logger.Managers; public interface ILogManager { - void Write(string message, ELogType logType = ELogType.INFO, bool? writeToConsole = null, - bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, + 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"); - void Write(Exception exception, string module = null, string method = null, bool criticalException = false, + 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 customSplunkSourceType = null, bool? sendToGrayLogServers = null, string grayLogFacility = null, string grayLogSource = null, string grayLogVersion = "1.1"); } \ No newline at end of file diff --git a/EonaCat.Logger/Managers/LogHelper.cs b/EonaCat.Logger/Managers/LogHelper.cs index 4db0566..0605b8c 100644 --- a/EonaCat.Logger/Managers/LogHelper.cs +++ b/EonaCat.Logger/Managers/LogHelper.cs @@ -261,4 +261,14 @@ internal static class LogHelper }); } } + + internal static string GetStartupMessage() + { + return $"{DllInfo.ApplicationName} started."; + } + + internal static string GetStopMessage() + { + return $"{DllInfo.ApplicationName} stopped."; + } } \ No newline at end of file diff --git a/EonaCat.Logger/Managers/LogManager.cs b/EonaCat.Logger/Managers/LogManager.cs index 14a7ea7..1518aab 100644 --- a/EonaCat.Logger/Managers/LogManager.cs +++ b/EonaCat.Logger/Managers/LogManager.cs @@ -21,6 +21,7 @@ public class LogManager : ILogManager, IDisposable private readonly CancellationTokenSource _tokenSource = new(); private DateTime _logDate; + private bool _isDisposing; public LogManager(LoggerSettings settings, string serverIp, int serverPort) { @@ -68,31 +69,33 @@ public class LogManager : ILogManager, IDisposable GC.SuppressFinalize(this); } - public void Write(Exception exception, string module = null, string method = null, bool criticalException = false, + 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 customSplunkSourceType = null, bool? sendToGrayLogServers = null, string grayLogFacility = null, string grayLogSource = null, string grayLogVersion = "1.1") { if (exception == null) + { return; + } - Write(exception.FormatExceptionToMessage(module, method), + await WriteAsync(exception.FormatExceptionToMessage(module, method), criticalException ? ELogType.CRITICAL : ELogType.ERROR, writeToConsole, sendToSysLogServers, sendToSplunkServers, customSplunkSourceType, sendToGrayLogServers, grayLogFacility, grayLogSource, grayLogVersion); } - public void Write(string message, ELogType logType = ELogType.INFO, bool? writeToConsole = null, - bool? sendToSysLogServers = null, bool? sendToSplunkServers = null, string? customSplunkSourceType = null, + 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; - if (!IsRunning) StartNewLogAsync().ConfigureAwait(false); - InternalWriteAsync(CurrentDateTme, message, logType, writeToConsole, sendToSysLogServers, sendToSplunkServers, - customSplunkSourceType, sendToGrayLogServers, grayLogFacility, grayLogSource, grayLogVersion); + await InternalWriteAsync(CurrentDateTme, message, logType, writeToConsole, sendToSysLogServers, sendToSplunkServers, + customSplunkSourceType, sendToGrayLogServers, grayLogFacility, grayLogSource, grayLogVersion).ConfigureAwait(false); } public event EventHandler OnException; @@ -113,14 +116,22 @@ public class LogManager : ILogManager, IDisposable protected virtual async Task DisposeAsync(bool disposing) { - if (disposing) await StopLoggingAsync().ConfigureAwait(false); + if (disposing) + { + _isDisposing = true; + await StopLoggingAsync().ConfigureAwait(false); + await Task.Delay(100).ConfigureAwait(false); + } } public async Task StartNewLogAsync() { if (_tokenSource.IsCancellationRequested) return; - if (IsRunning && CurrentDateTme.Date > _logDate.Date) await StopLoggingAsync().ConfigureAwait(false); + if (IsRunning && CurrentDateTme.Date > _logDate.Date) + { + await StopLoggingAsync().ConfigureAwait(false); + } IsRunning = true; @@ -158,6 +169,7 @@ public class LogManager : ILogManager, IDisposable LoggerProvider = serviceProvider.GetService(); LoggerFactory = serviceProvider.GetService(); Logger = LoggerFactory.CreateLogger(Settings.Id); + LogHelper.SendToFile(Logger, Settings, ELogType.INFO, LogHelper.GetStartupMessage()); } @@ -169,6 +181,16 @@ public class LogManager : ILogManager, IDisposable if (string.IsNullOrEmpty(message) || logType == ELogType.NONE || (int)logType > (int)Settings.MaxLogType) return; + if (_isDisposing) + { + return; + } + + if (!IsRunning) + { + await StartNewLogAsync().ConfigureAwait(false); + } + var messageWithHeader = LogHelper.FormatMessageWithHeader(Settings, logType, message, dateTime); var writeToConsoleValue = writeToConsole ?? Settings.EnableConsole; var sendToSyslogServersValue = sendToSyslogServers ?? Settings.SendToSyslogServers; @@ -233,15 +255,9 @@ public class LogManager : ILogManager, IDisposable private void SetupLogManager() { AppDomain.CurrentDomain.ProcessExit += ProcessExit; - Console.CancelKeyPress += Console_CancelKeyPress; _logDate = CurrentDateTme; } - private void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e) - { - Dispose(); - } - private void ProcessExit(object sender, EventArgs e) { Dispose(); @@ -249,10 +265,17 @@ public class LogManager : ILogManager, IDisposable 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 (CurrentLogFile != null) diff --git a/Testers/EonaCat.Logger.Test.Web/Logger.cs b/Testers/EonaCat.Logger.Test.Web/Logger.cs index 0e35cd0..cf6e0c0 100644 --- a/Testers/EonaCat.Logger.Test.Web/Logger.cs +++ b/Testers/EonaCat.Logger.Test.Web/Logger.cs @@ -85,22 +85,22 @@ public static class Logger } } - public static void Log(string message, ELogType logType = ELogType.INFO, bool writeToConsole = true) + public static async Task LogAsync(string message, ELogType logType = ELogType.INFO, bool writeToConsole = true) { if (IsDisabled) return; - LogManager.Write(message, logType, writeToConsole); + await LogManager.WriteAsync(message, logType, writeToConsole).ConfigureAwait(false); } - public static void Log(Exception exception, string message = "", bool writeToConsole = true) + public static async Task LogAsync(Exception exception, string message = "", bool writeToConsole = true) { if (IsDisabled) return; if (ELogType.ERROR <= MaxLogType) { - LogManager.Write(exception, message, writeToConsole: writeToConsole); + await LogManager.WriteAsync(exception, message, writeToConsole: writeToConsole).ConfigureAwait(false); } } diff --git a/Testers/EonaCat.Logger.Test.Web/Program.cs b/Testers/EonaCat.Logger.Test.Web/Program.cs index 52884fb..1c3d7fa 100644 --- a/Testers/EonaCat.Logger.Test.Web/Program.cs +++ b/Testers/EonaCat.Logger.Test.Web/Program.cs @@ -10,9 +10,13 @@ using EonaCat.Web.Tracer.Extensions; var builder = WebApplication.CreateBuilder(args); // Add services to the container. +Logger.UseLocalTime = true; +Logger.MaxLogType = ELogType.TRACE; +Logger.Configure(); + var options = new FileLoggerOptions(); options.MaxRolloverFiles = 5; -options.FileSizeLimit = 1 * 1024 * 1024 / 4; +//options.FileSizeLimit = 1 * 1024 * 1024 / 4; options.UseLocalTime = true; builder.Logging.AddEonaCatFileLogger(fileLoggerOptions: options, filenamePrefix: "web"); @@ -61,10 +65,6 @@ builder.Services.AddMemoryCache(); var app = builder.Build(); -Logger.UseLocalTime = true; -Logger.MaxLogType = ELogType.TRACE; -Logger.Configure(); - // Configure the HTTP request pipeline. if (!app.Environment.IsDevelopment()) { @@ -116,7 +116,7 @@ void RunLoggingExceptionTests() } catch (Exception exception) { - logger.Write(exception); + logger.WriteAsync(exception).ConfigureAwait(false); Console.WriteLine($"Normal ExceptionLogged: {i}"); } @@ -124,11 +124,11 @@ void RunLoggingExceptionTests() } } -//Task.Run(RunWebLoggerTests); -//Task.Run(RunWebLoggingTests); -Task.Run(RunLoggingTests); -//Task.Run(RunLoggingExceptionTests); -//Task.Run(RunWebLoggingExceptionTests); +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); void RunWebLoggingExceptionTests() { @@ -153,14 +153,17 @@ void RunWebLoggingExceptionTests() } } -void RunWebLoggingTests() +async void RunWebLoggingTests() { if (!Directory.Exists(Logger.LogFolder)) Directory.CreateDirectory(Logger.LogFolder); for (var i = 0; i < 9000000; i++) { app.Logger.LogInformation($"web-test {i}"); - File.AppendAllText(Path.Combine(Logger.LogFolder, "test.log"), $"WebLogged: {i}{Environment.NewLine}"); + using (var file = new StreamWriter(Path.Combine(Logger.LogFolder, "test.log"), true)) + { + await file.WriteAsync($"WebLogged: {i}{Environment.NewLine}").ConfigureAwait(false); + } Console.WriteLine($"WebLogged: {i}"); Task.Delay(1); } @@ -171,7 +174,7 @@ void RunLoggingTests() var loggerSettings = new LoggerSettings(); loggerSettings.UseLocalTime = true; loggerSettings.FileLoggerOptions.UseLocalTime = true; - loggerSettings.MaxLogType = ELogType.INFO; + loggerSettings.MaxLogType = ELogType.DEBUG; loggerSettings.FileLoggerOptions.FileSizeLimit = 1024 * 1024 * 1; loggerSettings.FileLoggerOptions.FileNamePrefix = "AllTypes"; loggerSettings.FileLoggerOptions.MaxRolloverFiles = 5; @@ -179,14 +182,14 @@ void RunLoggingTests() for (var i = 0; i < 9000000; i++) { - logger.Write($"test to file {i} INFO"); - logger.Write($"test to file {i} CRITICAL", ELogType.CRITICAL); - logger.Write($"test to file {i} DEBUG", ELogType.DEBUG); - logger.Write($"test to file {i} ERROR", ELogType.ERROR); - logger.Write($"test to file {i} TRACE", ELogType.TRACE); - logger.Write($"test to file {i} TRAFFIC", ELogType.TRAFFIC); - logger.Write($"test to file {i} WARNING", ELogType.WARNING); - logger.Write($"test to file {i} NONE", ELogType.NONE); + 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); Console.WriteLine($"Logged: {i}"); Task.Delay(1); } @@ -194,16 +197,21 @@ void RunLoggingTests() void RunWebLoggerTests() { - for (var i = 0; i < 9000000; i++) + var i = 0; + while (true) { - Logger.Log($"test via logger {i} INFO"); - Logger.Log($"test via logger {i} CRITICAL", ELogType.CRITICAL); - Logger.Log($"test via logger {i} DEBUG", ELogType.DEBUG); - Logger.Log($"test via logger {i} ERROR", ELogType.ERROR); - Logger.Log($"test via logger {i} TRACE", ELogType.TRACE); - Logger.Log($"test via logger {i} TRAFFIC", ELogType.TRAFFIC); - Logger.Log($"test via logger {i} WARNING", ELogType.WARNING); - Logger.Log($"test via logger {i} NONE", ELogType.NONE); + i++; + Task.Run(() => + { + 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); }