private static TraceEventType GetLoggingSeverity(LoggingSeverity loggingSeverity)
{
TraceEventType severity;
switch (loggingSeverity)
{
case LoggingSeverity.Critical:
severity = TraceEventType.Critical;
break;
case LoggingSeverity.Error:
severity = TraceEventType.Error;
break;
case LoggingSeverity.Warning:
severity = TraceEventType.Warning;
break;
case LoggingSeverity.Information:
severity = TraceEventType.Information;
break;
case LoggingSeverity.Debug:
severity = TraceEventType.Verbose;
break;
default:
severity = TraceEventType.Information;
break;
}
return severity;
}
public static void Log(LoggingSeverity severity, string message)
{
string severityPrefix = string.Format("[{0}]", severity.ToString().ToUpper());
SetConsoleColor(severity);
Console.WriteLine(string.Format("[{0}]{1} : {2}", DateTime.Now.ToString(), severityPrefix, message));
}
public LogEntry(string message, Collection<string> categories, LoggingSeverity loggingSeverity)
{
Message = message;
Severity = GetLoggingSeverity(loggingSeverity);
TimeStamp = DateTime.Now;
Categories = new List<string>(categories);
}
public static void Initialize(string logFilePath = null, bool useBackgroundTask = false, LoggingSeverity severity = LoggingSeverity.Debug, LoggingMode mode = LoggingMode.File)
{
FilePath = logFilePath.IsNullOrBlankString() ? $@"Logs\{GetCurrentDateString()}.log" : logFilePath;
Severity = severity;
Mode = mode;
UseBackgroundTask = useBackgroundTask;
if (UseBackgroundTask)
{
_logQueue = new ConcurrentQueue <LogEntry>();
_backgroundTask =
Task
.Run
(() =>
{
while (!_stopLoggingRequested)
{
if (!_logQueue.TryPeek(out LogEntry lastEntry))
{
continue;
}
LogImpl(lastEntry);
_logQueue.TryDequeue(out lastEntry);
}
});
}
}
/// <summary>
/// Log exception.
/// </summary>
/// <param name="ex">The excption need be logged.</param>
/// <param name="severity">The severity of this exception, default value is <see cref="LoggingSeverity.Error" />.</param>
public void LogException(Exception ex, LoggingSeverity severity = LoggingSeverity.Error)
{
string message = new StringBuilder(ex.Message).AppendLine().Append(ex.StackTrace).ToString();
//Log
WriteLog(message, severity);
}
/// <summary>
/// Log messages with the severity type and the specified inner exception.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="innerException">The inner exception.</param>
/// <param name="format">The message format string.</param>
/// <param name="arguments">The message format argument array.</param>
public virtual void Log(LoggingSeverity severity, Exception innerException, string format, params object[] arguments)
{
switch (severity)
{
case LoggingSeverity.Debug:
Debug(innerException, format, arguments);
break;
case LoggingSeverity.Info:
Info(innerException, format, arguments);
break;
case LoggingSeverity.Warn:
Warn(innerException, format, arguments);
break;
case LoggingSeverity.Error:
Error(innerException, format, arguments);
break;
case LoggingSeverity.Fatal:
Fatal(innerException, format, arguments);
break;
default:
break;
}
}
public LogMessage(LoggingSeverity logSeverity, string source, string message, string createdBy, DateTime createdDate)
{
LogSeverity = logSeverity;
Source = source;
Message = message;
CreatedBy = createdBy;
CreatedDate = createdDate;
}
public static void Write(this ILogger logger, LoggingSeverity severity, string message, params object[] args)
{
logger.Write(new LogMessage
{
Severity = severity,
Message = String.Format(message, args)
});
}
private LogEntry(LoggingSeverity severity, string message, Exception exception = null)
{
message.AssertHasText(nameof(message));
Severity = severity;
Message = message;
Exception = exception;
Time = DateTime.Now;
}
public LogEntry(string message, Exception exception, LoggingSeverity loggingSeverity)
{
if (exception == null)
throw new ArgumentNullException("exception", "Exception object to log cannot be null.");
Message = String.Format(CultureInfo.CurrentCulture, "{0}\r\nException: {1}", message, exception);
Severity = GetLoggingSeverity(loggingSeverity);
TimeStamp = DateTime.Now;
Categories = new List<string> { exception.Source };
}
public ApiLog(LoggingType logType, LoggingSeverity logSeverity, LoggingPlatform platform, string routeDesc, string appVersion, int userKey, string logMessage)
{
Id = 0;
LogDate = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow,
TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time"));
LogTypeKey = (int)logType;
SeverityKey = (int)logSeverity;
PlatformKey = (int)platform;
RouteDesc = routeDesc;
AppVersion = appVersion;
UserKey = userKey == 0 ? 1 : userKey;
LogMessage = logMessage;
}
/// <summary>
/// Write log to log file.
/// </summary>
/// <param name="message">The log message which need be logged.</param>
/// <param name="severity">The error severity.</param>
/// <param name="requestId">The reqeust id.</param>
/// <remarks>The title property of <see cref="LogEntry" /> represents the request id.</remarks>
private void WriteLog(string message, LoggingSeverity severity, Guid?requestId = null)
{
if (DoesNeedLogging(severity))
{
LogEntry logEntry = new LogEntry()
{
TimeStamp = DateTime.UtcNow,
Message = new StringBuilder(severity.ToString()).Append(ASCII.SPACE).Append(message).ToString(),
};
logEntry.Title = String.Empty;
logEntry.Categories.Add(LoggerCategory);
EnterpriseLibraryContainer.Current.GetInstance <LogWriter>().Write(logEntry);
}
}
public static void Log(LoggingSeverity severity, params string[] messageAndParams)
{
string[] messageParams = messageAndParams.Skip(1).ToArray();
string message = String.Format(messageAndParams[0], messageParams);
switch (severity)
{
case LoggingSeverity.DEBUG:
Output(message); break;
case LoggingSeverity.WARN:
Output(message); break;
case LoggingSeverity.ERROR:
Output(message); break;
default:
break;
}
}
private static void SetConsoleColor(LoggingSeverity severity)
{
Console.ForegroundColor = ConsoleColor.White;
switch (severity)
{
case LoggingSeverity.Ciritical:
Console.ForegroundColor = ConsoleColor.DarkRed;
break;
case LoggingSeverity.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LoggingSeverity.Exception:
Console.ForegroundColor = ConsoleColor.DarkGreen;
break;
case LoggingSeverity.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
}
}
/// <summary>
/// Check whether need logging according to the severity.
/// </summary>
/// <param name="severity">The logging severity.</param>
/// <returns>true if need logging, else false.</returns>
private bool DoesNeedLogging(LoggingSeverity severity)
{
LoggingSeverity loggingSeveritySetting = (LoggingSeverity)Enum.Parse(typeof(LoggingSeverity), ConfigurationManager.AppSettings[ConfigurationKey.LOGGING_SEVERITY]);
#if DEBUG
if (loggingSeveritySetting >= severity)
{
return(true);
}
else
{
return(false);
}
#else
if (loggingSeveritySetting == LoggingSeverity.Fatal || loggingSeveritySetting == LoggingSeverity.Error)
{
return(true);
}
else
{
return(false);
}
#endif
}
/// <summary>
/// Logs the specified severity.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="logMessageGenerator">The log message generator.</param>
public virtual void Log(LoggingSeverity severity, LogMessageGenerator logMessageGenerator)
{
Log(severity, logMessageGenerator());
}
/// <summary>
/// Logs a message and exception to a severity level.
/// </summary>
/// <param name="message">Message to be logged</param>
/// <param name="loggingSeverity">Severity level of message</param>
/// <param name="loggedException">Exception to be logged</param>
public static void Log(string message, LoggingSeverity loggingSeverity, Exception loggedException)
{
if (string.IsNullOrWhiteSpace(message))
Log("Log message cannot be null, empty or have whitespace.", LoggingSeverity.Error);
if (loggedException == null)
Log("Log exception cannot be null.", LoggingSeverity.Error);
LogEntry logEntry = new LogEntry();
string exceptionMessage = String.Format(CultureInfo.CurrentCulture, "{0}\r\nException: {1}", message, loggedException);
logEntry.Message = exceptionMessage;
logEntry.SetLoggingSeverity(loggingSeverity);
Log(logEntry);
}
public static extern void SetLogLevel(LoggingSeverity level);
/// <summary>
/// Log messages with the severity type.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="format">The message format string.</param>
/// <param name="arguments">The message format argument array.</param>
public override void Log(LoggingSeverity severity, string format, params object[] arguments)
{
}
/// <summary>
/// Log messages with the severity type and the specified inner exception.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="innerException">The inner exception.</param>
/// <param name="format">The message format string.</param>
/// <param name="arguments">The message format argument array.</param>
public override void Log(LoggingSeverity severity, Exception innerException, string format, params object[] arguments)
{
}
public static LogEntry New(string message, LoggingSeverity severity, Exception exception)
{
return(new LogEntry(severity, message, exception));
}
public static LogEntry New(string message, LoggingSeverity severity)
{
return(new LogEntry(severity, message));
}
public void SetLoggingSeverity(LoggingSeverity loggingSeverity)
{
Severity = GetLoggingSeverity(loggingSeverity);
}
internal bool IsSeverityEnabled(LoggingSeverity loggingSeverity)
{
return((int)loggingSeverity >= (int)MinSeverity);
}
public LoggingPlatformAdapter SetMinSeverity(LoggingSeverity minSeverity)
{
MinSeverity = minSeverity;
return(this);
}
/// <summary>
/// Logs a message and exception to a severity level.
/// </summary>
/// <param name="message">Message to be logged</param>
/// <param name="loggingSeverity">Severity level of message</param>
public static void Log(string message, LoggingSeverity loggingSeverity)
{
if (string.IsNullOrWhiteSpace(message))
Log("Log message cannot be null, empty or have whitespace.", LoggingSeverity.Error);
LogEntry logEntry = new LogEntry();
logEntry.Message = message;
logEntry.SetLoggingSeverity(loggingSeverity);
Log(logEntry);
}
public void LogMessage(LoggingSeverity severity, string message)
{
System.Diagnostics.Debug.WriteLine(severity.ToString() + " : " + message);
}
protected virtual void LogInfo(int?userKey, LoggingSeverity logSeverity, string logMessage)
{
_sp.PostApiLog(new ApiLog(LoggingType.Info, logSeverity, LoggingPlatform.Api, HttpContext.Request.Path.Value,
_appVersion, userKey ?? 1, logMessage));
}
