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="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 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> /// 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> /// 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> /// 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; }