/// <summary>Write the log message for this log.</summary> protected override void WriteLogMessage(string msg, Logger.Severity severity) { switch (severity) { case Logger.Severity.Off: break; case Logger.Severity.Error: Trace.TraceError(msg); break; case Logger.Severity.Warning: Trace.TraceWarning(msg); break; case Logger.Severity.Info: Trace.TraceInformation(msg); break; case Logger.Severity.Verbose: case Logger.Severity.Verbose2: case Logger.Severity.Verbose3: Trace.WriteLine(msg); break; } Flush(); }
private MailLogProvider(string from, string to, string subject, Logger.Severity treshold) { _from = from; _to = to; _subject = subject; Treshold = treshold; }
/// <summary>Format the log message into the format used by this log.</summary> protected override string FormatLogMessage( DateTime timestamp, Logger.Severity severity, TraceLogger.LoggerType loggerType, string caller, string message, IPEndPoint myIPEndPoint, Exception exception, int errorCode) { // Don't include stack trace in Warning messages for Console output. bool includeStackTrace = severity <= Logger.Severity.Error; if (!useCompactConsoleOutput) { return(base.FormatLogMessage_Impl(timestamp, severity, loggerType, caller, message, myIPEndPoint, exception, errorCode, includeStackTrace)); } string msg = String.Format(logFormat, TraceLogger.PrintTime(timestamp), //0 TraceLogger.SeverityTable[(int)severity], //1 errorCode, //2 caller, //3 message, //4 includeStackTrace ? TraceLogger.PrintException(exception) : TraceLogger.PrintExceptionWithoutStackTrace(exception)); //5 return(msg); }
public void Log( Logger.Severity severity, TraceLogger.LoggerType loggerType, string caller, string message, IPEndPoint myIPEndPoint, Exception exception, int errorCode) { var now = DateTime.UtcNow; var msg = FormatLogMessage( now, severity, loggerType, caller, message, myIPEndPoint, exception, errorCode); try { WriteLogMessage(msg, severity); } catch (Exception exc) { Trace.TraceError("Error writing log message {0} -- Exception={1}", msg, exc); } }
public static void Throw <T>(string message, Logger.Severity severity = Logger.Severity.Major) where T : Exception { var exception = (T)Activator.CreateInstance(typeof(T), message); Logger.Write(exception, severity); throw exception; }
public LogItem(string message, Logger.Severity severity) { TimeStamp = DateTime.Now; Message = message; Severity = severity; RethrowIfErrorOccursWhileLogging = true; }
internal static ILogProvider CreateFromConfiguration() { LoggersSection configurationManager = LoggersSection.GetFromConfiguration(); DebugLoggerElement debugLoggerElement = configurationManager.DebugLogger; Logger.Severity treshold = debugLoggerElement.Treshold; return(new DebugLogProvider(treshold)); }
public LogItem(Exception exception, Logger.Severity severity) { TimeStamp = DateTime.Now; Message = exception.Message; CallStack = exception.StackTrace; Severity = severity; RethrowIfErrorOccursWhileLogging = true; }
public static ILogProvider CreateFromConfiguration() { LoggersSection configurationManager = LoggersSection.GetFromConfiguration(); FileLoggerElement fileLoggerElement = configurationManager.FileLogger; string filename = fileLoggerElement.Filename; Logger.Severity treshold = fileLoggerElement.Treshold; return(new FileLogProvider(filename, treshold)); }
/// <summary> /// The method to call during logging to write the log message by this log. /// </summary> /// <param name="msg">Message string to be writter</param> /// <param name="severity">The severity level of this message</param> protected override void WriteLogMessage(string msg, Logger.Severity severity) { if (severity == Logger.Severity.Off) { return; } MessageContent messageContent = msg.FromJson <MessageContent>(); this.TraceLogger.Log(GetLogLevel(severity), messageContent.Message, messageContent.Tag, messageContent.ErrorCode, messageContent.ErrorCodeMsg, null, null, messageContent.Payload); }
/// <summary> /// The method to call during logging to format the log info into a string ready for output. /// </summary> /// <param name="severity">The severity of the message being traced.</param> /// <param name="loggerType">The type of logger the message is being traced through.</param> /// <param name="caller">The name of the logger tracing the message.</param> /// <param name="myIPEndPoint">The <see cref="IPEndPoint"/> of the Orleans client/server if known. May be null.</param> /// <param name="message">The message to log.</param> /// <param name="exception">The exception to log. May be null.</param> /// <param name="eventCode">Numeric event code for this log entry. May be zero, meaning 'Unspecified'.</param> protected virtual string FormatLogMessage( DateTime timestamp, Logger.Severity severity, TraceLogger.LoggerType loggerType, string caller, string message, IPEndPoint myIPEndPoint, Exception exception, int errorCode) { return(FormatLogMessage_Impl(timestamp, severity, loggerType, caller, message, myIPEndPoint, exception, errorCode, true)); }
internal static ILogProvider CreateFromConfiguration() { LoggersSection configurationManager = LoggersSection.GetFromConfiguration(); MailLoggerElement fileLoggerElement = configurationManager.MailLogger; string from = fileLoggerElement.From; string to = fileLoggerElement.To; string subject = fileLoggerElement.Subject; Logger.Severity treshold = fileLoggerElement.Treshold; return(new MailLogProvider(from, to, subject, treshold)); }
/// <summary>Write the log message for this log.</summary> protected override void WriteLogMessage(string msg, Logger.Severity severity) { lock (lockObj) { if (logOutput == null) { return; } logOutput.WriteLine(msg); if (useFlush) { logOutput.Flush(); // We need to explicitly flush each log write } } }
private static void Log(Logger.Severity severity, string message, object eventSource, Exception exception, string details = null) { try { using (StreamWriter streamWriter = new StreamWriter(Logger.LogFilePath, true)) { string str1 = eventSource == null ? "" : string.Format(" ({0})", eventSource); string str2 = exception == null ? "" : string.Format("\n\n Exception: {0} - {1}\n{2}", (object)exception, (object)exception.Message, (object)exception.StackTrace); string str3 = details == null || exception != null && details == exception.Message ? "" : string.Format("\n\n{0}", (object)details); streamWriter.WriteLine("{0} [{1}]: {2}{3}{4}{5}\n", (object)DateTime.Now.ToLocalTime(), (object)severity, (object)message, (object)str1, (object)str2, (object)str3); } } catch { } }
private static int GetLogLevel(Logger.Severity severity) { switch (severity) { case Logger.Severity.Error: return(2); case Logger.Severity.Warning: return(3); case Logger.Severity.Info: return(4); default: return(5); } }
// Implementation private static string SeverityOf(Logger.Severity level) { switch (level) { case Logger.Severity.Severe: return("FATAL"); case Logger.Severity.Warn: return("WARN"); case Logger.Severity.Info: return("INFO"); default: return("DEBUG"); } }
/// <summary> /// The method to call during logging to format the log info into a string ready for output. /// </summary> /// <param name="timestamp">The timestamp.</param> /// <param name="severity">The severity of the message being traced.</param> /// <param name="loggerType">The type of logger the message is being traced through.</param> /// <param name="caller">The name of the logger tracing the message.</param> /// <param name="message">The message to log.</param> /// <param name="myIPEndPoint">The <see cref="T:System.Net.IPEndPoint" /> of the Orleans client/server if known. May be null.</param> /// <param name="exception">The exception to log. May be null.</param> /// <param name="errorCode">Numeric event code for this log entry. May be zero, meaning 'Unspecified'.</param> /// <returns>System.String.</returns> protected override string FormatLogMessage(DateTime timestamp, Logger.Severity severity, TraceLogger.LoggerType loggerType, string caller, string message, IPEndPoint myIPEndPoint, Exception exception, int errorCode) { string tag = GetLogTypeTag(loggerType); if (errorCode < 0) { errorCode = -errorCode; } Dictionary <string, object> payload = new Dictionary <string, object> { { "IpEndPoint", myIPEndPoint?.ToString() }, { "SourceSeverity", severity }, { "SourceTimestamp", timestamp } }; MessageContent messageContent = BuildLogMessageContent( $"{caller}: {message}", tag, Convert.ToUInt64(errorCode), string.Empty, null, exception, payload); return(messageContent.ToJson()); }
protected string FormatLogMessage_Impl( DateTime timestamp, Logger.Severity severity, TraceLogger.LoggerType loggerType, string caller, string message, IPEndPoint myIPEndPoint, Exception exception, int errorCode, bool includeStackTrace) { if (severity == Logger.Severity.Error) { message = "!!!!!!!!!! " + message; } string ip = myIPEndPoint == null ? String.Empty : myIPEndPoint.ToString(); if (loggerType.Equals(TraceLogger.LoggerType.Grain)) { // Grain identifies itself, so I don't want an additional long string in the prefix. // This is just a temporal solution to ease the dev. process, can remove later. ip = String.Empty; } string exc = includeStackTrace ? TraceLogger.PrintException(exception) : TraceLogger.PrintExceptionWithoutStackTrace(exception); string msg = String.Format("[{0} {1,5}\t{2}\t{3}\t{4}\t{5}]\t{6}\t{7}", TraceLogger.ShowDate ? TraceLogger.PrintDate(timestamp) : TraceLogger.PrintTime(timestamp), //0 Thread.CurrentThread.ManagedThreadId, //1 TraceLogger.SeverityTable[(int)severity], //2 errorCode, //3 caller, //4 ip, //5 message, //6 exc); //7 return(msg); }
public FileLogProvider(string filename, Logger.Severity treshold) { _logfile = ConvertToAbsolutePath(filename); Treshold = treshold; }
internal DebugLogProvider(Logger.Severity treshold) { Treshold = treshold; }
/// <summary> /// Output message directly to log file -- no formatting is performed. /// </summary> /// <param name="msg">Message text to be logged.</param> /// <param name="severity">Severity of this log message -- ignored.</param> public void WriteToLog(string msg, Logger.Severity severity) { WriteLogMessage(msg, severity); }
/// <summary>Write the log message for this log.</summary> protected override void WriteLogMessage(string msg, Logger.Severity severity) { Console.WriteLine(msg); }
/// <summary> /// The method to call during logging to write the log message by this log. /// </summary> /// <param name="msg">Message string to be writter</param> /// <param name="severity">The severity level of this message</param> protected abstract void WriteLogMessage(string msg, Logger.Severity severity);
public Log(string msg, Logger.Severity severity, StackTrace stack = null) { Message = msg; Severity = severity; Stack = stack; }
public LogMessage(string message, Logger.Severity severity, DateTime timestamp) { _timestamp = timestamp; _severity = severity; _message = message; }