Fortunevale/Xorog.Logger
Archived
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

Init

Browse source
This commit is contained in:
XorogVEVO 2021-11-28 13:51:07 +01:00
parent 22d1c2f48c
commit f1b58b8885
3 changed files with 333 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

300
Logger.cs Normal file
View file

@ -0,0 +1,300 @@
using System.Text;
namespace Xorog.Logger;
public class Logger
{
private static bool loggerStarted = false;
private static LoggerObjects.LogLevel maxLogLevel = LoggerObjects.LogLevel.DEBUG;
private static string FileName = "";
private static FileStream? OpenedFile { get; set; }
private readonly static LoggerObjects _loggerObjects = new();
private static Task? RunningLogger = null;
/// <summary>
/// Starts the logger with specified settings
/// </summary>
/// <param name="filePath">Where the current logs should be saved to, leave blank if logs shouldnt be saved</param>
/// <param name="level">The loglevel that should be displayed in the console, does not affect whats written to file</param>
/// <param name="cleanUpBefore">Clean up old logs before a datetime</param>
/// <returns>A bool stating if the logger was started</returns>
public static void StartLogger(string filePath = "", LoggerObjects.LogLevel level = LoggerObjects.LogLevel.DEBUG, DateTime cleanUpBefore = new DateTime(), bool ThrowOnFailedDeletion = false)
{
if (loggerStarted)
throw new Exception($"The logger is already started");
if (filePath is not "")
{
FileName = filePath;
OpenedFile = File.Open(FileName, FileMode.Append);
}
loggerStarted = true;
maxLogLevel = level;
if (cleanUpBefore != new DateTime())
{
foreach (var b in Directory.GetFiles("logs"))
{
try
{
FileInfo fi = new(b);
if (fi.CreationTimeUtc < cleanUpBefore)
{
fi.Delete();
LogDebug(null, $"{fi.Name} deleted");
}
}
catch (Exception ex)
{
if (!ThrowOnFailedDeletion)
LogError(null, $"Couldn't delete log file {b}: {ex}");
else
throw new Exception($"Failed to delete {b}: {ex}");
}
}
}
RunningLogger = Task.Run(async () =>
{
while (loggerStarted)
{
try
{
if (_loggerObjects.LogsToPost.Count == 0)
{
Thread.Sleep(10);
continue;
}
foreach (var b in _loggerObjects.LogsToPost.ToList())
{
string LogLevelText = b.LogLevel.ToString();
ConsoleColor LogLevelColor = ConsoleColor.Gray;
LogLevelColor = b.LogLevel switch
{
LoggerObjects.LogLevel.DEBUG => ConsoleColor.Gray,
LoggerObjects.LogLevel.INFO => ConsoleColor.Green,
LoggerObjects.LogLevel.WARN => ConsoleColor.Yellow,
LoggerObjects.LogLevel.ERROR => ConsoleColor.Red,
LoggerObjects.LogLevel.FATAL => ConsoleColor.DarkRed,
_ => ConsoleColor.Gray
};
if (b.LogLevel == LoggerObjects.LogLevel.DEBUG && maxLogLevel >= LoggerObjects.LogLevel.DEBUG)
{
Console.ResetColor(); Console.Write($"[{b.TimeOfEvent:dd.MM.yyyy HH:mm:ss} | {(b.Source is not null ? b.Source.GetType().Namespace : "??")}/{(b.Source is not null ? b.Source.GetType().Name : "??")}] ");
Console.ForegroundColor = LogLevelColor; Console.Write($"[{LogLevelText}] ");
Console.ResetColor(); Console.WriteLine(b.Message);
_loggerObjects.LogsToPost.Remove(b);
}
else if (b.LogLevel == LoggerObjects.LogLevel.INFO && maxLogLevel >= LoggerObjects.LogLevel.INFO)
{
Console.ResetColor(); Console.Write($"[{b.TimeOfEvent:dd.MM.yyyy HH:mm:ss} | {(b.Source is not null ? b.Source.GetType().Namespace : "??")}/{(b.Source is not null ? b.Source.GetType().Name : "??")}] ");
Console.ForegroundColor = LogLevelColor; Console.Write($"[{LogLevelText}] ");
Console.ResetColor(); Console.WriteLine(b.Message);
_loggerObjects.LogsToPost.Remove(b);
}
else if (b.LogLevel == LoggerObjects.LogLevel.WARN && maxLogLevel >= LoggerObjects.LogLevel.WARN)
{
Console.ResetColor(); Console.Write($"[{b.TimeOfEvent:dd.MM.yyyy HH:mm:ss} | {(b.Source is not null ? b.Source.GetType().Namespace : "??")}/{(b.Source is not null ? b.Source.GetType().Name : "??")}] ");
Console.ForegroundColor = LogLevelColor; Console.Write($"[{LogLevelText}] ");
Console.ResetColor(); Console.WriteLine(b.Message);
_loggerObjects.LogsToPost.Remove(b);
}
else if (b.LogLevel == LoggerObjects.LogLevel.ERROR && maxLogLevel >= LoggerObjects.LogLevel.ERROR)
{
Console.ResetColor(); Console.Write($"[{b.TimeOfEvent:dd.MM.yyyy HH:mm:ss} | {(b.Source is not null ? b.Source.GetType().Namespace : "??")}/{(b.Source is not null ? b.Source.GetType().Name : "??")}] ");
Console.ForegroundColor = LogLevelColor; Console.Write($"[{LogLevelText}] ");
Console.ResetColor(); Console.WriteLine(b.Message);
_loggerObjects.LogsToPost.Remove(b);
}
else if (b.LogLevel == LoggerObjects.LogLevel.FATAL && maxLogLevel >= LoggerObjects.LogLevel.FATAL)
{
Console.ResetColor(); Console.Write($"[{b.TimeOfEvent:dd.MM.yyyy HH:mm:ss} | {(b.Source is not null ? b.Source.GetType().Namespace : "??")}/{(b.Source is not null ? b.Source.GetType().Name : "??")}] ");
Console.ForegroundColor = LogLevelColor; Console.Write($"[{LogLevelText}] ");
Console.ResetColor(); Console.WriteLine(b.Message);
_loggerObjects.LogsToPost.Remove(b);
}
else
{
Console.ResetColor(); Console.Write($"[{b.TimeOfEvent:dd.MM.yyyy HH:mm:ss} | {(b.Source is not null ? b.Source.GetType().Namespace : "??")}/{(b.Source is not null ? b.Source.GetType().Name : "??")}] ");
Console.ForegroundColor = LogLevelColor; Console.Write($"[{LogLevelText}] ");
Console.ResetColor(); Console.WriteLine(b.Message);
_loggerObjects.LogsToPost.Remove(b);
}
try
{
Byte[] FileWrite = Encoding.UTF8.GetBytes($"[{b.TimeOfEvent:dd.MM.yyyy HH:mm:ss} | {(b.Source is not null ? b.Source.GetType().Namespace : "??")}/{(b.Source is not null ? b.Source.GetType().Name : "??")}] [{LogLevelText}] {b.Message}\n");
if (OpenedFile != null)
{
await OpenedFile.WriteAsync(FileWrite.AsMemory(0, FileWrite.Length));
OpenedFile.Flush();
}
}
catch (Exception ex)
{
LogFatal(null, $"Couldn't write log to file: {ex}");
}
}
}
catch (Exception ex)
{
Console.ResetColor(); Console.Write($"[{DateTime.Now:dd.MM.yyyy HH:mm:ss} | ??/??] ");
Console.ForegroundColor = ConsoleColor.DarkRed; Console.Write($"[FATAL] ");
Console.ResetColor(); Console.WriteLine($"An error occured while logging: {ex}");
await Task.Delay(1000);
continue;
}
}
});
}
/// <summary>
/// Stops the logger
/// </summary>
public static void StopLogger()
{
loggerStarted = false;
maxLogLevel = LoggerObjects.LogLevel.DEBUG;
FileName = "";
Thread.Sleep(500);
if (RunningLogger is not null)
RunningLogger.Dispose();
RunningLogger = null;
if (OpenedFile is not null)
OpenedFile.Close();
}
/// <summary>
/// Changes the log level
/// </summary>
/// <param name="level"></param>
public static void ChangeLogLevel(LoggerObjects.LogLevel level)
{
maxLogLevel = level;
}
/// <summary>
/// Log without any LogLevel
/// </summary>
/// <param name="sender"></param>
/// <param name="message"></param>
public static void Log(object? sender, string message)
{
_loggerObjects.LogsToPost.Add(new LoggerObjects.LogEntry
{
TimeOfEvent = DateTime.Now,
LogLevel = LoggerObjects.LogLevel.NONE,
Message = message,
Source = sender
});
}
/// <summary>
/// Log with debug log level
/// </summary>
/// <param name="sender"></param>
/// <param name="message"></param>
public static void LogDebug(object? sender, string message)
{
_loggerObjects.LogsToPost.Add(new LoggerObjects.LogEntry
{
TimeOfEvent = DateTime.Now,
LogLevel = LoggerObjects.LogLevel.DEBUG,
Message = message,
Source = sender
});
}
/// <summary>
/// Log with info log level
/// </summary>
/// <param name="sender"></param>
/// <param name="message"></param>
public static void LogInfo(object? sender, string message)
{
_loggerObjects.LogsToPost.Add(new LoggerObjects.LogEntry
{
TimeOfEvent = DateTime.Now,
LogLevel = LoggerObjects.LogLevel.INFO,
Message = message,
Source = sender
});
}
/// <summary>
/// Log with warn log level
/// </summary>
/// <param name="sender"></param>
/// <param name="message"></param>
public static void LogWarn(object? sender, string message)
{
_loggerObjects.LogsToPost.Add(new LoggerObjects.LogEntry
{
TimeOfEvent = DateTime.Now,
LogLevel = LoggerObjects.LogLevel.WARN,
Message = message,
Source = sender
});
}
/// <summary>
/// Log with error log level
/// </summary>
/// <param name="sender"></param>
/// <param name="message"></param>
public static void LogError(object? sender, string message)
{
_loggerObjects.LogsToPost.Add(new LoggerObjects.LogEntry
{
TimeOfEvent = DateTime.Now,
LogLevel = LoggerObjects.LogLevel.ERROR,
Message = message,
Source = sender
});
}
/// <summary>
/// Log with fatal log level
/// </summary>
/// <param name="sender"></param>
/// <param name="message"></param>
public static void LogFatal(object? sender, string message)
{
_loggerObjects.LogsToPost.Add(new LoggerObjects.LogEntry
{
TimeOfEvent = DateTime.Now,
LogLevel = LoggerObjects.LogLevel.FATAL,
Message = message,
Source = sender
});
}
}

24
LoggerObjects.cs Normal file
View file

@ -0,0 +1,24 @@
namespace Xorog.Logger;
public class LoggerObjects
{
internal List<LogEntry> LogsToPost = new();
internal class LogEntry
{
public DateTime TimeOfEvent { get; set; }
public LogLevel LogLevel { get; set; }
public object? Source { get; set; } = new object();
public string? Message { get; set; }
}
public enum LogLevel
{
FATAL,
ERROR,
WARN,
INFO,
DEBUG,
NONE
}
}

9
Xorog.Logger.csproj Normal file
View file

@ -0,0 +1,9 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
</Project>