public static void Log(LogLevel level, string message, Exception ex = null)
{
LogMessage logMessage = new LogMessage {
DateLogged = System.DateTime.Now, Level = level, Message = message
};
LogMessages.Add(logMessage);
NewLog?.Invoke(null, new System.ComponentModel.AddingNewEventArgs {
NewObject = logMessage
});
switch (level)
{
case LogLevel.Debug: log.Debug(message, ex); break;
case LogLevel.Info: log.Info(message, ex); break;
case LogLevel.Warning: log.Warn(message, ex); break;
case LogLevel.Error: log.Error(message, ex); break;
case LogLevel.SponsorMessage: log.Info(message, ex); break;
case LogLevel.Advertisement: log.Info(message, ex); break;
}
}
/// <summary>
/// Logs a new message and calls all loggers in this factory to inform them of the new log
/// </summary>
/// <param name="message">The message to log</param>
/// <param name="level">The level of severity for this log message. The default is Information</param>
/// <param name="origin">The origin of this log message. Useful for tracing. The default is the method name of the caller</param>
/// <example>
/// From inside MyFunction() => Logger.Log("Some message")
/// returns: "Some message --MyFunction()"
/// </example>
public void Log(string message, LogFactoryLevel level = LogFactoryLevel.Information, [CallerMemberName] string origin = "")
{
// Add method name if specified
if (this.LogMethodName)
{
message = string.Format(this.LogMethodNameFormat, message, origin);
}
// Send message to all loggers
mLoggers.ForEach(f => f.Log(level, message));
SafeWait(() =>
{
// Add to list
mLogHistory.Add(new LogDetails {
Date = DateTime.UtcNow, Level = level, Message = message
});
// Prune list
if (mLogHistory.Count > 200)
{
mLogHistory.RemoveAt(0);
}
});
// Inform listeners
NewLog?.Invoke(message, level);
}
public void Write(string log)
{
MaxCount = MaxCount > 1 ? MaxCount : 1000;
MaxCount = MaxCount < 100000 ? MaxCount : 1000;
var s = $"[{DateTime.Now.ToString("yyyyMMdd HH:mm:ss")}] {log}";
System.Diagnostics.Debug.WriteLine(s);
try
{
System.IO.File.AppendAllText(File, s + "\r\n");
}
catch (Exception ex)
{
Items.Add(ex.Message);
}
Items.Add(s);
if (Items.Count > MaxCount)
{
var k = Items.Count - MaxCount + 10;
k = k < Items.Count ? k : Items.Count;
Items.RemoveRange(Items.Count - k, k);
}
NewLog?.Invoke(this, new LogMessage {
Message = s, Time = DateTime.Now
});
}
/// <summary>
/// Error log
/// </summary>
/// <param name="exception">Exception to log</param>
/// <param name="objName">CallerMemberName</param>
public void Error(Exception exception, [CallerMemberName] string objName = "")
{
var message = $"[{LoggerName}]\r\nMessage: {exception.Message}\r\nStackTrace: {exception.StackTrace}" +
$"\r\nSource: {exception.Source}";
NewLog?.Invoke(objName, new LogArgs(message, LogLevel.Error, LoggerName));
}
private static void Log(LogMessage Message)
{
byte[] data = Encoding.UTF8.GetBytes(Message.ToString() + "\r\n");
fs.Write(data, 0, data.Length);
fs.Flush();
NewLog?.Invoke(Message);
}
public void OnNewLog(GameObject log)
{
var newLog = new LogEventArgs {
Logs = log
};
NewLog?.Invoke(this, newLog);
}
public static void Log(LogType Type, ConsoleColor Color, string Severity, string Message)
{
LogMessage msg = new LogMessage(Type, Color, Severity, Message);
messages.Add(msg);
if (Entrance.IsHandler)
{
Console.WriteLine(JsonConvert.SerializeObject(msg));
NewLog?.Invoke(msg);
}
else
{
Log(msg);
}
}
/// <summary>
/// Logs the message to a file
/// </summary>
/// <param name="logMessage"> The message to log </param>
/// <param name="logLevel"> The log's output severity </param>
/// <param name="callerOrigin"> Where the logger was called from </param>
/// <param name="filePath"> The path where the log came from </param>
/// <param name="lineNumber"> The line number where the log was called </param>
public void Log(string logMessage, LogLevel logLevel = LogLevel.Normal, [CallerMemberName] string callerOrigin = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0)
{
lock (_synchronizingObject)
{
// Setup log message format
string message =
$"[{logLevel}]{Environment.NewLine}" +
$"[{Path.GetFileName(filePath)} > {callerOrigin}() > Line: {lineNumber}]" +
$"{Environment.NewLine}{logMessage}{Environment.NewLine}";
// Write log message to log file
File.AppendAllText(AppFiles.LogFilePath, message);
// Invoke log event
NewLog?.Invoke(logMessage, logLevel);
};
}
public static void Log(LogLevel level, string msg, Exception ex = null)
{
switch (level)
{
case LogLevel.Info:
log.Info(msg, ex);
break;
case LogLevel.Debug:
log.Debug(msg, ex);
break;
case LogLevel.Warn:
log.Warn(msg, ex);
break;
case LogLevel.Error:
log.Error(msg, ex);
break;
}
NewLog?.Invoke(null, new LogEventArgs(level, msg, ex));
}
/// <summary>
/// Information log
/// </summary>
/// <param name="message">Message to log</param>
/// <param name="objName">CallerMemberName</param>
public void Information(string message, [CallerMemberName] string objName = "")
{
NewLog?.Invoke(objName, new LogArgs(message, LogLevel.Info, LoggerName));
}
private static void OnNewLog(string text)
{
NewLog?.Invoke(text);
}
/// <inheritdoc /> public void Info(string message) => NewLog?.Invoke(this, new LogMessage(IMarkDocLogger.LogType.Info, message));
protected void Log(string text) => NewLog?.Invoke(text);
/// <inheritdoc /> public void Error(string message) => NewLog?.Invoke(this, new LogMessage(IMarkDocLogger.LogType.Error, message));
/// <inheritdoc /> public void Warning(string message) => NewLog?.Invoke(this, new LogMessage(IMarkDocLogger.LogType.Warning, message));
/// <summary>
/// Logs the message to console
/// </summary>
/// <param name="logMessage"> The message to log </param>
/// <param name="logLevel"> The log's output severity </param>
/// <param name="callerOrigin"> Where the logger was called from </param>
/// <param name="filePath"> The path where the log came from </param>
/// <param name="lineNumber"> The line number where the log was called </param>
public void Log(string logMessage, LogLevel logLevel = LogLevel.Info, [CallerMemberName] string callerOrigin = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0)
{
lock (_synchronizatingObject)
{
// Writes the LogLevel in a format I like
var writeLogLevel = new Action <LogLevel, ConsoleColor>((logLevel, colour) =>
{
// Write first character
Console.Write('[');
// Set colour and write the log level
Console.ForegroundColor = colour;
Console.Write($"{logLevel}");
// Reset console colours and add the last bracket
Console.ResetColor();
Console.WriteLine(']');
});
// Setup message format
switch (logLevel)
{
case LogLevel.Info:
{
writeLogLevel(logLevel, ConsoleColor.Gray);
break;
};
case LogLevel.Warning:
{
writeLogLevel(logLevel, ConsoleColor.Yellow);
break;
};
case LogLevel.Error:
{
writeLogLevel(logLevel, ConsoleColor.Red);
break;
};
case LogLevel.Critical:
{
writeLogLevel(logLevel, ConsoleColor.DarkRed);
break;
};
default:
{
writeLogLevel(logLevel, ConsoleColor.Gray);
break;
};
}
;
// Setup log message format
string message = $"[{Path.GetFileName(filePath)} > {callerOrigin}() > Line: {lineNumber}]" +
$"{Environment.NewLine}{logMessage}{Environment.NewLine}";
// Log to the console
Console.WriteLine(message);
// Invoke event
NewLog?.Invoke(logMessage, logLevel);
};
}
protected virtual void OnNewLog(string prio, string message, Exception ex = null)
{
NewLog?.Invoke(this, new NewLogEventArgs(prio, message, ex));
}
/// <summary>
/// Warning log
/// </summary>
/// <param name="message">Message to log</param>
/// <param name="objName">CallerMemberName</param>
public void Warning(string message, [CallerMemberName] string objName = "")
{
NewLog?.Invoke(objName, new LogArgs(message, LogLevel.Warning, LoggerName));
}
