public Configuration(int stationId, string hwid, string server, Logger.LogLevels logLevel)
{
this.StationId = stationId;
this.Hwid = hwid;
this.Server = server;
this.LogLevel = logLevel;
}
/// <summary>
/// Set up logging for the tool.
/// </summary>
/// <param name="fileLogPath">The path to the desired log file</param>
/// <param name="flushEachLine">A flag controlling whether to flush each line</param>
public static void SetupFileLogger(string fileLogPath, bool flushEachLine = true)
{
Logger.LogDecorations decorations = Logger.LogDecorations.None;
// Normal log level for the tool, printing everything but debug messages.
Logger.LogLevels levels = Logger.LogLevels.All & ~Logger.LogLevels.Debug;
#if DEBUG
decorations = Logger.LogDecorations.All;
levels = Logger.LogLevels.All;
#endif
FileLog fileLog = new FileLog
{
LogLevels = levels,
LogDecorations = decorations,
LogFilePath = fileLogPath
};
fileLog.FlushEachLine = flushEachLine;
Logger.Info(
"Log file is located under: {0}",
fileLog.LogFilePath);
Logger.Info();
AddProvider(fileLog);
}
/// <summary>
/// Processes and returns the log message
/// </summary>
/// <param name="logDecoration">log decoration</param>
/// <param name="logLevel">log level</param>
/// <returns>log message</returns>
public string GetLogMessage(Logger.LogDecorations logDecoration, Logger.LogLevels logLevel)
{
StringBuilder messageBuilder = new StringBuilder(this.logMessage.Length);
messageBuilder.Insert(0, this.logMessage);
if (logDecoration != Logger.LogDecorations.None)
{
if (logDecoration.HasFlag(Logger.LogDecorations.Detail))
{
messageBuilder.Insert(0, this.logDetailInfo);
}
if (logDecoration.HasFlag(Logger.LogDecorations.LogLevel))
{
messageBuilder.Insert(0, this.logLevelInfo);
}
if (logDecoration.HasFlag(Logger.LogDecorations.Time))
{
messageBuilder.Insert(0, this.logTimeInfo);
}
}
// Check to see if we need to add exception info to message.
if (logLevel.HasFlag(Logger.LogLevels.ExpStack) &&
(this.logMessageArgs != null) &&
(this.logMessageArgs[0] is ExpMessageArg))
{
messageBuilder.Append(Environment.NewLine + this.GetExceptionStackLog());
}
return(messageBuilder.ToString());
}
internal override void Write(DateTime timeStamp, Logger.LogLevels lvl, Thread currentExecThread, string className, string msg)
{
if (lvl <= outLevel)
{
File.AppendAllText(fileName, FormatMessage(timeStamp, lvl, currentExecThread.Name ?? currentExecThread.ManagedThreadId.ToString(), className, msg));
}
}
public LoggerLiveMessageEventArgs(DateTime time, Logger.LogLevels level, String header, String message)
{
LogTime = time;
LogLevel = level;
Header = header;
Message = message;
}
internal static void LogData(Logger.LogLevels level, Thread currentExecThread, string className, string msg)
{
if (LogLevel >= level)
{
DateTime time = DateTime.Now;
LogTargets.ForEach(item => item.Write(time, level, currentExecThread, className, msg));
}
}
public virtual ILogMessage CreateMessage(Logger.LogLevels logLevel, string message, IMessageArg[] messageArgs)
{
StackTrace st = new StackTrace(true);
// We use stack frame = 4 since we need the previous 4th function call stack that called us.
LogMessage logMessage = new LogMessage(logLevel, message, st.GetFrame(4), messageArgs);
return(logMessage);
}
public FileLogTarget(string logFileName, Logger.LogLevels allowedLevel = Logger.LogLevels.TRACE, bool createEmptyLogFile = false)
{
fileName = logFileName;
if (createEmptyLogFile && File.Exists(fileName))
{
File.Delete(fileName);
}
outLevel = allowedLevel;
}
internal void writeLog(Logger.LogLevels level, string tag, string message)
{
if (this.FLFile == null)
{
log.log((int)level, tag, message);
}
else
{
log.log((int)level, "[" + this.FLFile + "] " + tag, message);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LogMessage" /> class.
/// </summary>
/// <param name="logLevel">log level</param>
/// <param name="logMessage">log message</param>
/// <param name="funcStackFrame">function stack frame</param>
/// <param name="messageArgs">message arguments</param>
public LogMessage(
Logger.LogLevels logLevel,
string logMessage,
StackFrame funcStackFrame,
IEnumerable <IMessageArg> messageArgs)
{
this.LogLevel = logLevel;
this.logMessage = logMessage;
if (messageArgs != null)
{
this.logMessageArgs = new List <IMessageArg>(messageArgs);
}
this.FillInLogArgs(messageArgs);
this.GenerateLogDecorations(funcStackFrame);
}
/// <summary>
/// If available, sets the console's foreground color based on the level.
/// </summary>
/// <param name="level">The level to use when setting the foreground color.</param>
private void SafeSetConsoleColorFromLogLevel(Logger.LogLevels level)
{
ConsoleColor targetColor = ConsoleColor.White;
switch (level)
{
case Logger.LogLevels.Error:
case Logger.LogLevels.Exp:
targetColor = ConsoleColor.Red;
break;
case Logger.LogLevels.Warning:
targetColor = ConsoleColor.Yellow;
break;
}
this.consoleForegroundColor.SetValue(null, targetColor);
}
/// <summary>
/// Setup console logging for the tool
/// </summary>
public static void SetupConsoleLogger()
{
Logger.LogDecorations decorations = Logger.LogDecorations.None;
// Normal log level for the tool, printing everything but debug messages.
Logger.LogLevels levels = Logger.LogLevels.All & ~Logger.LogLevels.Debug;
#if DEBUG
decorations = Logger.LogDecorations.All;
levels = Logger.LogLevels.All;
#endif
ConsoleLog consoleLog = new ConsoleLog
{
LogLevels = levels,
LogDecorations = decorations
};
AddProvider(consoleLog);
}
internal override void Write(DateTime timeStamp, Logger.LogLevels lvl, Thread currentExecThread, string className, string msg)
{
string threadName = currentExecThread.Name ?? currentExecThread.ManagedThreadId.ToString();
switch (lvl)
{
case Logger.LogLevels.FATAL: HighLight("FATAL", ConsoleColor.White, ConsoleColor.Red); break;
case Logger.LogLevels.ERROR: HighLight("ERROR", ConsoleColor.Red, ConsoleColor.Black); break;
case Logger.LogLevels.WARN: HighLight("WARN", ConsoleColor.Yellow, ConsoleColor.Black); break;
case Logger.LogLevels.DEBUG: HighLight("DEBUG", ConsoleColor.White, ConsoleColor.DarkBlue); break;
case Logger.LogLevels.TRACE: HighLight("TRACE", ConsoleColor.Cyan, ConsoleColor.Black); break;
default:
Console.Write(FormatMessage(timeStamp, lvl, threadName, className, msg));
break;
}
void HighLight(string pattern, ConsoleColor fontColor, ConsoleColor backgroundColor)
{
int idx = msg.IndexOf($"] {pattern} ");
Console.Write($"{DateTime.Now.ToString("dd-MM HH:mm:ss.fff")} [{threadName}] ");
Console.BackgroundColor = backgroundColor;
Console.ForegroundColor = fontColor;
Console.Write($"{lvl.ToString()}");
Console.BackgroundColor = stdBgColor;
Console.ForegroundColor = stdFgColor;
Console.Write($" {className} - {msg}{Environment.NewLine}");
}
}
protected string FormatMessage(DateTime timeStamp, Logger.LogLevels lvl, string threadName, string className, string msg) => $"{timeStamp.ToString("dd-MM HH:mm:ss.fff")} [{threadName}] {lvl.ToString()} {className} - {msg}{Environment.NewLine}";
internal abstract void Write(DateTime timeStamp, Logger.LogLevels lvl, Thread currentExecThread, string className, string msg);
