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