private void Log(LoggerSeverity severity, string message, params object[] args)
{
string severityStr = severity.ToString().ToUpper();
message = string.Format("[{0}][{1}]: {2}", Name, severityStr, message);
Logger.Log(message, args);
}
public LoggerData(string message, LoggerSeverity.LogSeverities severity, Dictionary<string, string> extendedProperties)
{
this.Timestamp = DateTime.Now;
this.Message = message;
this.Severity = severity;
this.ExtendedProperties = extendedProperties;
}
/// <summary>
/// </summary>
/// <param name="severity"></param>
/// <param name="entry"></param>
/// <param name="formatParameters"></param>
public override void Log(LoggerSeverity severity, object entry, params object[] formatParameters)
{
foreach (Logger logger in m_loggers)
{
logger.Log(severity, entry, formatParameters);
}
}
public void Log(string message, LoggerSeverity severity, object reference = null)
{
LoggerSeverity getMostSevere(int s)
{
int i = 0;
while (s != 0)
{
s /= 2;
i++;
}
return((LoggerSeverity)(1 << (i - 1)));
}
int sev = ((int)severity & (int)Take);
if (sev == 0)
{
return;
}
Console.ForegroundColor = _colorTable[getMostSevere(sev)];
Console.WriteLine($"[{severity.ToString()}][{message}]");
Console.ResetColor();
OnLog?.Invoke(message, severity, reference);
}
/// <summary>
/// Defaults the callback create logger.
/// </summary>
/// <param name="className">Name of the class.</param>
/// <param name="threshold">The threshold.</param>
/// <returns></returns>
public virtual Logger DefaultCallbackCreateLogger(string className, LoggerSeverity threshold)
{
Logger result = new CompositeLogger(ApplicationLogger.Current);
result.Threshold = threshold;
result.Category = className;
return(result);
}
/// <summary>
/// Does the format entry.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="utcOffset">The utc offset.</param>
/// <param name="logEntry">The log entry.</param>
/// <param name="category">The category.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
protected override string DoFormatEntry(LoggerSeverity severity, DateTime timestamp, TimeSpan?utcOffset, string logEntry, string category, Dictionary <string, object> data)
{
if (!string.IsNullOrEmpty(category))
{
category = " " + category;
}
return(string.Format(FormatString, timestamp.ToString("s"), severity, logEntry, Thread.CurrentThread.ManagedThreadId, category, DateTimeUtlities.TrimTimeSpan(DateTimeUtlities.ToStringTimeSpan(utcOffset))));
}
/// <summary>
/// Initializes a new instance of the <see cref="LogArtifact"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="rawEntry">The raw entry.</param>
/// <param name="rawFormatParameters">The raw format parameters.</param>
/// <param name="formattedMessage">The formatted message.</param>
public LogArtifact(Logger logger, LoggerSeverity severity, DateTime timestamp, object rawEntry, object[] rawFormatParameters, string formattedMessage)
{
Logger = logger;
Severity = severity;
Timestamp = timestamp;
RawEntry = rawEntry;
RawFormatParameters = rawFormatParameters;
FormattedMessage = formattedMessage;
}
/// <summary>
/// Initializes a new instance of the <see cref="LogArtifact"/> class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="rawEntry">The raw entry.</param>
/// <param name="rawFormatParameters">The raw format parameters.</param>
/// <param name="formattedMessage">The formatted message.</param>
public LogArtifact(Logger logger, LoggerSeverity severity, DateTime timestamp, object rawEntry, object[] rawFormatParameters, string formattedMessage)
{
Logger = logger;
Severity = severity;
Timestamp = timestamp;
RawEntry = rawEntry;
RawFormatParameters = rawFormatParameters;
FormattedMessage = formattedMessage;
}
/// <summary>
/// Initializes a new instance of the <see cref="TextLogger"/> class
/// with the provided log level and sink.
/// </summary>
/// <param name="logLevel">Minimum severity of the messages that should be logged</param>
/// <param name="sink">Text logger sink to write messages to</param>
public TextLogger(LoggerSeverity logLevel, ITextLoggerSink sink)
{
if (sink == null)
{
throw new ArgumentNullException(nameof(sink));
}
LogLevel = logLevel;
this.sink = sink;
}
/// <summary>
/// Posts the process new logger.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="threshold">The threshold.</param>
/// <param name="logger">The logger.</param>
protected virtual void PostProcessNewLogger(string key, LoggerSeverity threshold, Logger logger)
{
if (logger == null)
{
throw new InvalidOperationException("Create logger delegate returned a null logger");
}
PrepareLogger(threshold, logger);
m_loggers[key] = logger;
}
/// <summary>
/// </summary>
/// <param name="severity"></param>
/// <param name="entry"></param>
/// <param name="formatParameters"></param>
public override void Log(LoggerSeverity severity, object entry, params object[] formatParameters)
{
Category = m_prefix;
if (severity == LoggerSeverity.Fatal50)
{
// TODO call a notification interface, which could do something like
// send an email
}
base.Log(severity, entry, formatParameters);
}
/// <summary>
/// Creates the logger.
/// </summary>
/// <param name="className">Name of the class.</param>
/// <param name="threshold">The threshold.</param>
/// <returns></returns>
public virtual Logger CreateLogger(string className, LoggerSeverity threshold)
{
Logger logger = CreateLogger(className);
if (logger != null)
{
logger.Threshold = threshold;
}
return(logger);
}
public static void LogAndThrow <TEx>(this ILogger logger, LoggerSeverity sev, string message, object objectRef = null)
where TEx : Exception
{
if (!sev.HasFlag(LoggerSeverity.Error))
{
sev |= LoggerSeverity.Error;
}
logger?.Log(message, sev, objectRef);
throw new HereticException(typeof(TEx).Initialize <TEx>(message), message, sev, objectRef);
}
/// <summary>
/// Gets the name of the file.
/// </summary>
/// <param name="severity"></param>
/// <param name="timestamp"></param>
/// <param name="entry"></param>
/// <param name="formatParameters"></param>
/// <param name="logLine"></param>
/// <param name="artifactSet"></param>
/// <returns></returns>
public override string GetFileName(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine, LogArtifact[] artifactSet)
{
string fileName = base.GetFileName(severity, timestamp, entry, formatParameters, logLine, artifactSet);
if (Strategy != null)
{
fileName = Strategy.GetFileName(fileName, severity, timestamp, entry, formatParameters, logLine, artifactSet);
}
return fileName;
}
/// <summary>
/// Gets the name of the file.
/// </summary>
/// <param name="severity"></param>
/// <param name="timestamp"></param>
/// <param name="entry"></param>
/// <param name="formatParameters"></param>
/// <param name="logLine"></param>
/// <param name="artifactSet"></param>
/// <returns></returns>
public override string GetFileName(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine, LogArtifact[] artifactSet)
{
string fileName = base.GetFileName(severity, timestamp, entry, formatParameters, logLine, artifactSet);
if (Strategy != null)
{
fileName = Strategy.GetFileName(fileName, severity, timestamp, entry, formatParameters, logLine, artifactSet);
}
return(fileName);
}
public HereticException(Exception inner, string message, LoggerSeverity severity = LoggerSeverity.Error, object cause = null)
: base(message, inner)
{
if (!severity.HasFlag(LoggerSeverity.Error))
{
severity |= LoggerSeverity.Error;
}
Cause = cause;
Severity = severity;
}
/// <summary>
/// Does the format entry.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="logEntry">The log entry.</param>
/// <param name="category">The category.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
protected override string DoFormatEntry(LoggerSeverity severity, DateTime timestamp, string logEntry, string category, Dictionary<string, object> data)
{
return string.Format(
FormatString,
timestamp.ToString("yyyy-MM-ddTHH:mm:ss.fff"),
severity,
logEntry,
category,
Thread.CurrentThread.ManagedThreadId,
m_appDomainId,
m_utcOffsetStr
);
}
/// <summary>
/// Gets the type of the event log entry.
/// </summary>
/// <param name="loggerSeverity">The logger severity.</param>
/// <returns></returns>
public static EventLogEntryType GetEventLogEntryType(LoggerSeverity loggerSeverity)
{
switch (loggerSeverity)
{
case LoggerSeverity.Error40:
case LoggerSeverity.Fatal50:
case LoggerSeverity.Infinity:
return(EventLogEntryType.Error);
case LoggerSeverity.Warn30:
return(EventLogEntryType.Warning);
default:
return(EventLogEntryType.Information);
}
}
/// <summary>
/// </summary>
/// <param name="severity"></param>
/// <param name="entry"></param>
/// <param name="formatParameters"></param>
public virtual void Log(LoggerSeverity severity, object entry, params object[] formatParameters)
{
try
{
// Get the current timestamp
DateTime timestamp = m_timestampProvider.Now;
TimeSpan?utcOffset = m_timestampProvider.UtcOffset;
// Check all the filters
if (m_filters != null)
{
foreach (ILogFilter filter in m_filters)
{
if (!filter.IsLoggable(m_threshold, severity, timestamp, entry, formatParameters))
{
return;
}
}
}
string logLine = null;
if (m_formatter == null)
{
if (entry != null)
{
logLine = entry.ToString();
}
}
else
{
logLine = Formatter.FormatEntry(severity, timestamp, utcOffset, entry, formatParameters, m_category, m_data);
}
DoLog(severity, timestamp, entry, formatParameters, logLine);
}
#if DEBUG
catch (Exception ex)
{
Console.WriteLine(ExceptionUtilities.GetHumanReadableExceptionDetailsAsString(ex));
}
#else
catch (Exception)
{
}
#endif
}
/// <summary>
/// Gets the name of the file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <param name="logLine">The log line.</param>
/// <param name="artifactSet">The artifact set.</param>
/// <returns></returns>
public string GetFileName(string fileName, LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine, LogArtifact[] artifactSet)
{
// First, find the largest numbered file
string[] pieces = FileSystemUtilities.SplitFileIntoDirectoryAndName(fileName, true);
string search = pieces[1].Replace("{0}", "*");
string[] files = Directory.GetFiles(pieces[0], search);
int maxNumber = 0;
// Now, build the list of numbers from the file names
if (files != null)
{
foreach (string foundFile in files)
{
int foundNumber = StringUtilities.ExtractFirstNumber(Path.GetFileName(foundFile));
if (foundNumber > maxNumber)
{
maxNumber = foundNumber;
}
}
}
if (maxNumber == 0)
{
fileName = string.Format(fileName, maxNumber + 1);
}
else
{
string checkFileName = string.Format(fileName, maxNumber);
// Check if this file is too big or not
FileInfo info = new FileInfo(checkFileName);
if (info.Exists && info.Length >= MaxFileSize)
{
// Increment the file number
fileName = string.Format(fileName, maxNumber + 1);
}
else
{
fileName = checkFileName;
}
}
return(fileName);
}
public static void WriteLine(string Line, LoggerSeverity Severity, Exception e = null)
{
string strSeverity;
if (e != null)
{
Line += " (" + e.Message.Replace("\n", " ") + ")";
}
try {
if (Severity >= SeverityThreshold)
{
switch (Severity)
{
case LoggerSeverity.Critical:
strSeverity = "CRITICAL";
break;
case LoggerSeverity.Error:
strSeverity = "ERROR";
break;
case LoggerSeverity.Warning:
strSeverity = "WARNING";
break;
case LoggerSeverity.Info:
strSeverity = "INFORMATION";
break;
case LoggerSeverity.Debug:
default:
strSeverity = "DEBUG";
break;
}
using (StreamWriter sw = File.AppendText(FileName))
{
sw.WriteLine(DateTime.Now.ToString() + ": " + strSeverity + " " + Line);
Console.WriteLine(Line);
}
}
} catch (Exception ex)
{
Console.WriteLine("Unable to write to log file: " + ex.Message);
}
}
/// <summary>
/// Logs the exception.
/// </summary>
/// <param name="ex">The ex.</param>
/// <param name="severity">The severity.</param>
public override void LogException(Exception ex, LoggerSeverity severity)
{
}
/// <summary>
/// High level final log that is called with all of the detailed information
/// and the final log line as the last parameter.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <param name="logLine">The log line.</param>
protected override void DoLog(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine)
{
}
/// <summary>
/// Gets the name of the file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <param name="logLine">The log line.</param>
/// <param name="artifactSet">The artifact set.</param>
/// <returns></returns>
public string GetFileName(string fileName, LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine, LogArtifact[] artifactSet)
{
// First, find the largest numbered file
string[] pieces = FileSystemUtilities.SplitFileIntoDirectoryAndName(fileName, true);
string search = pieces[1].Replace("{0}", "*");
string[] files = Directory.GetFiles(pieces[0], search);
int maxNumber = 0;
// Now, build the list of numbers from the file names
if (files != null)
{
foreach (string foundFile in files)
{
int foundNumber = StringUtilities.ExtractFirstNumber(Path.GetFileName(foundFile));
if (foundNumber > maxNumber)
{
maxNumber = foundNumber;
}
}
}
if (maxNumber == 0)
{
fileName = string.Format(fileName, maxNumber + 1);
}
else
{
string checkFileName = string.Format(fileName, maxNumber);
// Check if this file is too big or not
FileInfo info = new FileInfo(checkFileName);
if (info.Exists && info.Length >= MaxFileSize)
{
// Increment the file number
fileName = string.Format(fileName, maxNumber + 1);
}
else
{
fileName = checkFileName;
}
}
return fileName;
}
/// <summary>
/// High level final log that is called with all of the detailed information
/// and the final log line as the last parameter.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <param name="logLine">The log line.</param>
protected virtual void DoLog(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine)
{
LogArtifact artifact = new LogArtifact(this, severity, timestamp, entry, formatParameters, logLine);
Logger.PushArtifact(artifact);
}
/// <summary>
/// High level final log that is called with all of the detailed information
/// and the final log line as the last parameter.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <param name="logLine">The log line.</param>
protected override void DoLog(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine)
{
m_cache = null;
m_sb.Append(logLine);
}
/// <summary>
/// </summary>
/// <param name="severity"></param>
/// <param name="entry"></param>
/// <param name="formatParameters"></param>
public override void Log(LoggerSeverity severity, object entry, params object[] formatParameters)
{
}
/// <summary>
/// Logs a message and exception information to the system log. This method will NOT throw an exception.
/// </summary>
/// <param name="message">The text to log.</param>
/// <param name="data">The byte data will be logged hexadecimal notation.</param>
/// <param name="startIndex">The start index in data to be included in the log.</param>
/// <param name="length">The length in data to be included in the log.</param>
/// <param name="ex">The exception to log, including its stack trace.</param>
/// <param name="severity">The severity of the event.</param>
protected virtual void Log(object message, byte[] data, int startIndex, int length, Exception ex, LoggerSeverity severity)
{
// I added this function so that the driver could have it's own verbosity.
// Compare Driver's Verbosity
if ((int)severity >= (int)_loggingVerbosity)
Trace.WriteLine(DateTime.Now.ToString("yyyy'-'MM'-'dd' 'HH':'mm':'ss'.'fff") + " " + message);
}
/// <summary>
/// Gets the name of the file.
/// </summary>
/// <returns></returns>
public virtual string GetFileName(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine, LogArtifact[] artifactSet)
{
return FileName;
}
/// <summary>
/// </summary>
/// <param name="severity"></param>
/// <param name="entry"></param>
/// <param name="formatParameters"></param>
public override void Log(LoggerSeverity severity, object entry, params object[] formatParameters)
{
Category = m_prefix;
if (severity == LoggerSeverity.Fatal50)
{
HandleFatalLog(severity, entry, formatParameters);
}
base.Log(severity, entry, formatParameters);
}
/// <summary>
/// Handles the fatal log.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
protected virtual void HandleFatalLog(LoggerSeverity severity, object entry, object[] formatParameters)
{
}
/// <summary>
/// Determines whether the specified severity is loggable.
/// </summary>
/// <param name="threshold">The threshold.</param>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <returns>
/// <c>true</c> if the specified severity is loggable; otherwise, <c>false</c>.
/// </returns>
public override bool IsLoggable(LoggerSeverity threshold, LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters)
{
return(severity == LoggerSeverity.Fatal50 ? true : base.IsLoggable(threshold, severity, timestamp, entry, formatParameters));
}
public void Log(string message, LoggerSeverity.LogSeverities severity, Dictionary<string, string> extendedProperties)
{
LoggerData loggerData = new LoggerData {
Message = message,
Severity = severity,
ExtendedProperties = extendedProperties
};
this.Log(loggerData);
}
public void Log(string message, LoggerSeverity.LogSeverities severity)
{
LoggerData loggerData = new LoggerData {
Message = message,
Severity = severity
};
this.Log(loggerData);
}
/// <summary>
/// Logs the exception.
/// </summary>
/// <param name="ex">The ex.</param>
/// <param name="severity">The severity.</param>
public override void LogException(Exception ex, LoggerSeverity severity)
{
}
/// <summary>
/// Logs a message to the system log. This method will NOT throw an exception.
/// </summary>
/// <param name="message">The text to log.</param>
/// <param name="data">The byte data will be logged hexadecimal notation.</param>
/// <param name="startIndex">The start index in data to be included in the log.</param>
/// <param name="length">The length in data to be included in the log.</param>
/// <param name="severity">The severity of the event.</param>
protected virtual void Log(object message, byte[] data, int startIndex, int length, LoggerSeverity severity)
{
Log(message, data, startIndex, length, null, severity);
}
/// <summary>
/// Logs a message and exception information to the system log. This method will NOT throw an exception.
/// </summary>
/// <param name="message">The text to log.</param>
/// <param name="ex">The exception to log, including its stack trace.</param>
/// <param name="severity">The severity of the event.</param>
protected virtual void Log(object message, Exception ex, LoggerSeverity severity)
{
Log(message, null, ex, severity);
}
/// <summary>
/// Creates the logger.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="threshold">The threshold.</param>
/// <returns></returns>
public virtual Logger CreateLogger(Type type, LoggerSeverity threshold)
{
return CreateLogger(type.FullName, threshold);
}
/// <summary>
/// Creates the logger.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="threshold">The threshold.</param>
/// <returns></returns>
public virtual Logger CreateLogger(Type type, LoggerSeverity threshold)
{
return(CreateLogger(type.FullName, threshold));
}
/// <summary>
/// High level final log that is called with all of the detailed information
/// and the final log line as the last parameter.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <param name="logLine">The log line.</param>
protected override void DoLog(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine)
{
m_cache = null;
m_sb.Append(logLine);
}
/// <summary> /// Does the format entry. /// </summary> /// <param name="severity">The severity.</param> /// <param name="timestamp">The timestamp.</param> /// <param name="utcOffset">The utc offset.</param> /// <param name="logEntry">The log entry.</param> /// <param name="category">The category.</param> /// <param name="data">The data.</param> /// <returns></returns> protected abstract string DoFormatEntry(LoggerSeverity severity, DateTime timestamp, TimeSpan?utcOffset, string logEntry, string category, Dictionary <string, object> data);
/// <summary>
/// Defaults the callback create logger.
/// </summary>
/// <param name="className">Name of the class.</param>
/// <param name="threshold">The threshold.</param>
/// <returns></returns>
public virtual Logger DefaultCallbackCreateLogger(string className, LoggerSeverity threshold)
{
Logger result = new CompositeLogger(ApplicationLogger.Current);
result.Threshold = threshold;
result.Category = className;
return result;
}
/// <summary>
/// Gets the working logger.
/// </summary>
/// <param name="threshold">The threshold.</param>
/// <returns></returns>
public virtual Logger GetWorkingLogger(LoggerSeverity threshold)
{
return(CreateLogger(typeof(Logger), threshold));
}
/// <summary>
/// Defaults the callback update logger.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="threshold">The threshold.</param>
public virtual void DefaultCallbackUpdateLogger(Logger logger, LoggerSeverity threshold)
{
logger.Threshold = threshold;
}
/// <summary>
/// Logs the exception.
/// </summary>
/// <param name="ex">The ex.</param>
/// <param name="severity">The severity.</param>
public virtual void LogException(Exception ex, LoggerSeverity severity)
{
Log(severity, ExceptionUtilities.GetExceptionDetailsAsString(ex));
}
/// <summary>
/// Gets the working logger.
/// </summary>
/// <param name="threshold">The threshold.</param>
/// <returns></returns>
public virtual Logger GetWorkingLogger(LoggerSeverity threshold)
{
return CreateLogger(typeof(Logger), threshold);
}
/// <summary>
/// Gets the name of the file.
/// </summary>
/// <returns></returns>
public virtual string GetFileName(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine, LogArtifact[] artifactSet)
{
return(FileName);
}
/// <summary>
/// Posts the process new logger.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="threshold">The threshold.</param>
/// <param name="logger">The logger.</param>
protected virtual void PostProcessNewLogger(string key, LoggerSeverity threshold, Logger logger)
{
if (logger == null)
{
throw new InvalidOperationException("Create logger delegate returned a null logger");
}
PrepareLogger(threshold, logger);
m_loggers[key] = logger;
}
/// <summary>
/// </summary>
/// <param name="severity"></param>
/// <param name="entry"></param>
/// <param name="formatParameters"></param>
public override void Log(LoggerSeverity severity, object entry, params object[] formatParameters)
{
}
/// <summary>
/// Prepares the logger.
/// </summary>
/// <param name="threshold">The threshold.</param>
/// <param name="logger">The logger.</param>
protected virtual void PrepareLogger(LoggerSeverity threshold, Logger logger)
{
logger.Enabled = threshold != OffValue;
}
/// <summary>
/// Logs a message to the system log. This method will NOT throw an exception.
/// </summary>
/// <param name="message">The text to log.</param>
/// <param name="severity">The severity of the event.</param>
protected virtual void Log(object message, LoggerSeverity severity)
{
Log(message, null, null, severity);
}
public void Write(string message, LoggerSeverity severity)
{
Console.WriteLine($"{severity}, {message}");
}
/// <summary>
/// Logs a message to the system log. This method will NOT throw an exception.
/// </summary>
/// <param name="message">The text to log.</param>
/// <param name="data">The byte data will be logged hexadecimal notation.</param>
/// <param name="severity">The severity of the event.</param
protected virtual void Log(object message, byte[] data, LoggerSeverity severity)
{
Log(message, data, null, severity);
}
/// <summary>
/// </summary>
/// <param name="severity"></param>
/// <param name="entry"></param>
/// <param name="formatParameters"></param>
public virtual void Log(LoggerSeverity severity, object entry, params object[] formatParameters)
{
try
{
// Get the current timestamp
DateTime timestamp = m_timestampProvider.Now;
// Check all the filters
if (m_filters != null)
{
foreach (ILogFilter filter in m_filters)
{
if (!filter.IsLoggable(m_threshold, severity, timestamp, entry, formatParameters))
{
return;
}
}
}
string logLine = null;
if (m_formatter == null)
{
if (entry != null)
{
logLine = entry.ToString();
}
}
else
{
logLine = Formatter.FormatEntry(severity, timestamp, entry, formatParameters, m_category, m_data);
}
DoLog(severity, timestamp, entry, formatParameters, logLine);
}
#if DEBUG
catch (Exception ex)
{
Console.WriteLine(ExceptionUtilities.GetHumanReadableExceptionDetailsAsString(ex));
}
#else
catch (Exception)
{
}
#endif
}
/// <summary>
/// Logs a message and exception information to the system log. This method will NOT throw an exception.
/// </summary>
/// <param name="message">The text to log.</param>
/// <param name="data">The byte data will be logged hexadecimal notation.</param>
/// <param name="ex">The exception to log, including its stack trace.</param>
/// <param name="severity">The severity of the event.</param>
protected virtual void Log(object message, byte[] data, Exception ex, LoggerSeverity severity)
{
int length = 0;
if (data != null)
length = data.Length;
Log(message, data, 0, length, ex, severity);
}
/// <summary>
/// Logs the exception.
/// </summary>
/// <param name="ex">The ex.</param>
/// <param name="severity">The severity.</param>
public virtual void LogException(Exception ex, LoggerSeverity severity)
{
Log(severity, ExceptionUtilities.GetExceptionDetailsAsString(ex));
}
/// <summary>
/// High level final log that is called with all of the detailed information
/// and the final log line as the last parameter.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <param name="logLine">The log line.</param>
protected virtual void DoLog(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine)
{
LogArtifact artifact = new LogArtifact(this, severity, timestamp, entry, formatParameters, logLine);
Logger.PushArtifact(artifact);
}
/// <summary>
/// Formats the entry.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="utcOffset">The utc offset.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <param name="category">The category.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
public string FormatEntry(LoggerSeverity severity, DateTime timestamp, TimeSpan?utcOffset, object entry, object[] formatParameters, string category, Dictionary <string, object> data)
{
string logEntry = PrepareEntry(entry, formatParameters);
return(DoFormatEntry(severity, timestamp, utcOffset, logEntry, category, data));
}
/// <summary>
/// Creates the logger.
/// </summary>
/// <param name="className">Name of the class.</param>
/// <param name="threshold">The threshold.</param>
/// <returns></returns>
public virtual Logger CreateLogger(string className, LoggerSeverity threshold)
{
Logger logger = CreateLogger(className);
if (logger != null)
{
logger.Threshold = threshold;
}
return logger;
}
/// <summary>
/// High level final log that is called with all of the detailed information
/// and the final log line as the last parameter.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="entry">The entry.</param>
/// <param name="formatParameters">The format parameters.</param>
/// <param name="logLine">The log line.</param>
protected override void DoLog(LoggerSeverity severity, DateTime timestamp, object entry, object[] formatParameters, string logLine)
{
}
