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-04-27 13:55:49 +02:00
parent 1a2838a796
commit 1f4f51adc5
7 changed files with 249 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
EonaCat.Logger/EonaCatCoreLogger/FileLoggerProvider.cs
View File

@@ -72,20 +72,34 @@ public class FileLoggerProvider : BatchingLoggerProvider
/// <inheritdoc />
protected override async Task WriteMessagesAsync(IEnumerable<LogMessage> messages,
CancellationToken cancellationToken)
{
if (IsWriting)
{
return;
}
IsWriting = true;
try
{
Directory.CreateDirectory(_path);
foreach (var group in messages.GroupBy(GetGrouping))
{
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;
}
await MoveRolloverLogFilesAsync(fileInfo, cancellationToken).ConfigureAwait(false);
// 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))
{
@@ -100,6 +114,17 @@ public class FileLoggerProvider : BatchingLoggerProvider
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<bool> TryWriteToFileAsync(CancellationToken cancellationToken)
{
@@ -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,107 +202,85 @@ public class FileLoggerProvider : BatchingLoggerProvider
return (message.Timestamp.Year, message.Timestamp.Month, message.Timestamp.Day);
}
private static void MoveFile(string copyFromPath, string copyToPath)
private readonly object lockObj = new object();
private async Task RollOverLogFile()
{
var origin = new FileInfo(copyFromPath);
origin.MoveTo(copyToPath);
var destination = new FileInfo(copyToPath);
destination.CreationTime = origin.CreationTime;
destination.LastWriteTime = origin.LastWriteTime;
destination.LastAccessTime = origin.LastAccessTime;
}
private async Task MoveRolloverLogFilesAsync(FileInfo fileInfo, CancellationToken cancellationToken)
lock (lockObj)
{
try
{
if (_maxFileSize > 0 && fileInfo.Exists && fileInfo.Length > _maxFileSize)
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--)
{
if (_maxRolloverFiles > 0 && _rollOverCount >= 0)
string currentFilePath = Path.Combine(directoryPath, $"{fileNameWithoutExtension}.{i}{fileExtension}");
string newFilePath = Path.Combine(directoryPath, $"{fileNameWithoutExtension}.{(i + 1)}{fileExtension}");
if (File.Exists(currentFilePath))
{
if (_rollOverCount < _maxRolloverFiles)
if (File.Exists(newFilePath))
{
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;
}
}
File.Delete(newFilePath);
}
File.Move(currentFilePath, newFilePath);
}
while (_rollingOver)
if (i != 1)
{
await Task.Delay(100, cancellationToken).ConfigureAwait(false);
}
}
catch (Exception exception)
{
OnError?.Invoke(this, new ErrorMessage { Message = "Cannot rollover files" });
}
}
private object _rollOverLock { get; set; } = new object();
/// <summary>
/// Rollover logFiles
/// </summary>
private void MoveRolloverLogFiles()
{
if (_maxRolloverFiles > 0 && _rollOverCount >= 0)
{
if (_rollOverCount >= _maxRolloverFiles)
{
var maxRollover = _rollOverCount;
bool hasPrefix = !string.IsNullOrWhiteSpace(_fileNamePrefix);
IEnumerable<FileInfo> 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;
currentFilePath = Path.Combine(directoryPath, $"{fileNameWithoutExtension}{fileExtension}");
newFilePath = Path.Combine(directoryPath, $"{fileNameWithoutExtension}.{i}{fileExtension}");
File.Move(currentFilePath, newFilePath);
}
var newFilename = Path.GetFileName(currentFile.FullName).Replace($"_{i}.log", $"_{i + 1}.log");
MoveFile(currentFile.FullName, $@"{Path.GetDirectoryName(currentFile.FullName)}\{newFilename}");
// 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);
});
}
_rollOverCount = 0;
catch (Exception ex)
{
// Log or handle the exception
Console.WriteLine($"Error occurred during log file rollover: {ex.Message}");
}
}
}
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
{
await WriteStartMessage().ConfigureAwait(false);
}
catch (Exception ex)
{
// Log or handle the exception
Console.WriteLine($"Error occurred during log file rollover: {ex.Message}");
}
}
/// <summary>
/// Deletes old log files, keeping a number of files defined by <see cref="FileLoggerOptions.RetainedFileCountLimit" />
/// </summary>

57
EonaCat.Logger/EonaCatCoreLogger/Internal/BatchingLoggerProvider.cs
View File

@@ -21,6 +21,8 @@ public abstract class BatchingLoggerProvider : ILoggerProvider, IDisposable
private ConcurrentQueue<LogMessage> _messageQueue;
private Task _outputTask;
private object _writeLock = new object();
private bool _isDisposing;
protected BatchingLoggerProvider(IOptions<BatchingLoggerOptions> 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<LogMessage> 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);
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<LogMessage> { new LogMessage() { Message = message, Timestamp = CurrentDateTimeOffset } }, _cancellationTokenSource.Token).ConfigureAwait(false);
}
private async Task WriteStopMessage()
{
var message = LogHelper.GetStopMessage();
await WriteMessagesAsync(new List<LogMessage> { 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<LogMessage>();
_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<LogMessage>(new List<LogMessage>
{ new() { Message = stopMessage, Timestamp = CurrentDateTme } }),
_cancellationTokenSource.Token)
.ConfigureAwait(false);
});
TaskCreationOptions.LongRunning);
return Task.CompletedTask;
}
private async Task StopAsync()

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

@@ -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");
}

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

@@ -261,4 +261,14 @@ internal static class LogHelper
});
}
}
internal static string GetStartupMessage()
{
return $"{DllInfo.ApplicationName} started.";
}
internal static string GetStopMessage()
{
return $"{DllInfo.ApplicationName} stopped.";
}
}

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

@@ -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<ErrorMessage> 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<ILoggerProvider>();
LoggerFactory = serviceProvider.GetService<ILoggerFactory>();
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)

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

@@ -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);
}
}

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

@@ -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);
}