protected override void PrintLog(string log, SeverityLevel severity)
{
switch (severity)
{
case SeverityLevel.Info:
case SeverityLevel.Debug:
{
Debug.Log(log);
break;
}
case SeverityLevel.Warning:
{
Debug.LogWarning(log);
break;
}
case SeverityLevel.Error:
case SeverityLevel.Fatal:
{
Debug.LogError(log);
break;
}
default:
break;
}
}
private void WriteMessage(string message, SeverityLevel severity)
{
foreach (var writer in Writers)
{
writer.WriteMessage(message, severity);
}
}
public RuleValidationResult(SeverityLevel severity, string ruleDescription, string violationDescription, Subtitle subtitle)
{
_subtitle = subtitle;
_severity = severity;
_description = violationDescription;
_ruleDescription = ruleDescription;
}
public void AddLog(SeverityLevel level, string ExceptionMessage, string ExceptionStacktrace, string customMessage)
{
try
{
var sqlCom = _db.GetWriteCommand( @"INSERT INTO logs
(
LogLevel,
ExceptionMessage,
ExceptionStacktrace,
CustomMessage,
Date
)
Values
(
@LogLevel,
@ExceptionMessage,
@ExceptionStacktrace,
@CustomMessage,
@Date
);" );
sqlCom.Parameters.AddWithValue( "@LogLevel", level.ToString() );
sqlCom.Parameters.AddWithValue( "@ExceptionMessage", ExceptionMessage );
sqlCom.Parameters.AddWithValue( "@ExceptionStacktrace", ExceptionStacktrace );
sqlCom.Parameters.AddWithValue( "@CustomMessage", customMessage );
sqlCom.Parameters.AddWithValue( "@Date", DateTime.Now );
sqlCom.ExecuteNonQuery();
}
finally
{
_db.CloseConnections();
}
}
public void LogValue(SeverityLevel level, object value, object owner, Exception ex = null)
{
var type = owner as Type;
var logger = type != null ? LogManager.GetLogger(type) : LogManager.GetLogger(Convert.ToString(owner));
if (value is NameValueCollection)
{
var collection = (NameValueCollection)value;
value = collection.Cast<string>().Aggregate<string, object>(string.Empty, (current, key) => (object)(current + ("Key: " + key + " Value: " + collection.Get(key))));
}
switch (level)
{
case SeverityLevel.Debug:
logger.Logger.Log(typeof(LoggingProvider), Level.Debug, value, ex);
break;
case SeverityLevel.Info:
logger.Logger.Log(typeof(LoggingProvider), Level.Info, value, ex);
break;
case SeverityLevel.Warn:
logger.Logger.Log(typeof(LoggingProvider), Level.Warn, value, ex);
break;
case SeverityLevel.Error:
logger.Logger.Log(typeof(LoggingProvider), Level.Error, value, ex);
break;
case SeverityLevel.Fatal:
logger.Logger.Log(typeof(LoggingProvider), Level.Fatal, value, ex);
break;
}
}
public void AddLog(SeverityLevel level, string ExceptionMessage, string ExceptionStacktrace, string customMessage)
{
var sqlCom = GetWriteCommand(@"INSERT INTO logs
(
LogLevel,
ExceptionMessage,
ExceptionStacktrace,
CustomMessage,
Date
)
Values
(
@LogLevel,
@ExceptionMessage,
@ExceptionStacktrace,
@CustomMessage,
@Date
);");
sqlCom.Parameters.AddWithValue("@LogLevel", level.ToString());
sqlCom.Parameters.AddWithValue("@ExceptionMessage", ExceptionMessage);
sqlCom.Parameters.AddWithValue("@ExceptionStacktrace", ExceptionStacktrace);
sqlCom.Parameters.AddWithValue("@CustomMessage", customMessage);
sqlCom.Parameters.AddWithValue("@Date", Utils.GetGermanNow());
sqlCom.ExecuteNonQuery();
}
public void WriteMessage(string message, SeverityLevel severityLevel)
{
try
{
string filename = ConfigurationManager.AppSettings["LogFileDirectory"] +
ConfigurationManager.AppSettings["LogFileName"] + DateTime.Now.ToShortDateString() + ".txt";
if (!File.Exists(filename))
{
File.Create(filename);
}
using (StreamWriter sw = File.AppendText(filename))
{
// Should be nice to include severity level on the logged message, original code didn't include it.
string.Format("{0} {1} {2}", DateTime.Now.ToShortDateString(), Enum.GetName(typeof(SeverityLevel), severityLevel), message);
sw.WriteLine(DateTime.Now.ToShortDateString() + message);
}
}
catch (NullReferenceException ex)
{
throw new JobLoggerException("Invalid configuration parameters.", ex);
}
catch (Exception ex)
{
throw new JobLoggerException("An error ocurred. See the inner exception for details.", ex);
}
}
public SyslogMessage(FacilityLevel facility,
SeverityLevel level,
string text)
{
m_Facility = facility;
m_Severity = level;
m_Text = text;
}
public ProjectExceptionArgs(string Messsage, SeverityLevel Severity)
{
this._message = Messsage;
// minimal defaults ..
this._severitylevel = Severity;
this._loglevel = LogLevel.Event;
}
private static void AddLogToDB(string exceptionMessage, string stackTrace, SeverityLevel lvl, string customMessage)
{
if (lvl >= ApplicationLogLevel)
{
var loggerDb = new UtilDatabase();
loggerDb.AddLog(lvl, exceptionMessage, stackTrace, customMessage);
}
}
public SyslogMessage(Message nfxMsg)
{
m_Severity = FromNFXLogMessageType(nfxMsg.Type);
m_Facility = FacilityLevel.User;
m_LocalTimeStamp = nfxMsg.TimeStamp;
m_Text = string.Format("{0} - {1} - {2}", nfxMsg.Topic, nfxMsg.From, nfxMsg.Text);
}
public CustomException(SeverityLevel severityLevel, LogLevel logLevel, Exception exception, String customMessage)
{
severityLevelOfException = severityLevel;
logLevelOfException = logLevel;
innerException = exception;
this.customMessage = customMessage;
}
public void Log(SeverityLevel severity, string message, params object[] args)
{
LogItems.Add(new LogItem
{
Message = string.Format(message, args),
Severity = severity,
Timestamp = DateTime.Now,
});
}
public ProjectExceptionArgs(string Message, string SourceClass, string SourceMethod, string SourceSnippet, SeverityLevel Severity, LogLevel Log)
{
this._message = Message;
this._sourceclass = SourceClass;
this._sourcemethod = SourceMethod;
this._sourcecodesnippet = SourceSnippet;
this._severitylevel = Severity;
this._loglevel = Log;
}
public override void Append(string message, SeverityLevel severity)
{
if (this.ShouldAppend(severity))
{
this.FormatByLayout(message, severity);
Console.WriteLine(this.FormattedMessage);
}
}
/// <summary>
/// Verify the output availability and log if possible
/// </summary>
public void Log(string log, SeverityLevel severity)
{
// Check if log should print
if (!Enabled || severity < MinPrintableSeverity)
{
return;
}
PrintLog(log, severity);
}
/// <summary>
/// Logs a message.
/// </summary>
/// <param name="message">The content of the message to log.</param>
/// <param name="severity">A value indicating the importance of the message.</param>
/// <returns>A task that represents the asynchronous operation.</returns>
public async Task LogMessageAsync(string message, SeverityLevel severity)
{
if (severity < _minSeverity)
{
return;
}
await Console.Out.WriteAsync(_header);
await Console.Out.WriteAsync(GetSeverityString(severity));
await Console.Out.WriteLineAsync(message);
}
public Problem(ICodeAnalyzer analyzer, SeverityLevel severity, String messageId, String message, String file, int line, String baseProjectPath, String projectName)
{
_analyzer = analyzer;
_severity = severity;
_messageId = messageId;
_message = message;
_file = file;
_line = line;
_baseProjectPath = baseProjectPath;
_projectName = projectName;
}
public string FormatMessage(string message, SeverityLevel severity, DateTime? time = null)
{
if (time == null)
{
time = DateTime.Now;
}
string formattedMessage = $"{time} - {severity} - {message}";
return formattedMessage;
}
public override void Append(string message, SeverityLevel severity)
{
if (this.ShouldAppend(severity))
{
this.FormatByLayout(message, severity);
using (var writer = new StreamWriter(this.FilePath, true))
{
writer.WriteLineAsync(this.FormattedMessage);
}
}
}
/// <summary>
/// Convert the severity to a recognizable String category
/// of Glimpse.
/// </summary>
/// <param name="severity">Severity level of telemetry. </param>
/// <returns> Glimpse category </returns>
public static string SeverityToCategory(SeverityLevel severity)
{
switch (severity)
{
case SeverityLevel.Error:
return "error";
case SeverityLevel.Information:
return "info";
case SeverityLevel.Warning:
return "warn";
default:
return severity.ToString();
}
}
bool ShouldProcessSeverityLevel(SeverityLevel sl)
{
// no filters specified,
// process all severity levels
if (GlobalFilters.Count == 0)
return true;
var result =
(from f in GlobalFilters.OfType<SeverityFilter>()
where f.EvaluateInternal(sl) == true
select 1)
.Any();
return result;
}
/// <summary>Writes the specified severity.</summary>
/// <param name="severity">The severity.</param>
/// <param name="title">The title.</param>
/// <param name="problem">The problem.</param>
/// <param name="solution">The solution.</param>
public void Write(SeverityLevel severity, [NotNull] string title, [NotNull] string problem, [NotNull] string solution)
{
Assert.ArgumentNotNull(title, "title");
Assert.ArgumentNotNull(problem, "problem");
Assert.ArgumentNotNull(solution, "solution");
var record = new Record
{
Title = title,
Problem = problem,
Solution = solution,
Severity = severity
};
this.messages.Add(record);
}
public string FormatMessage(string message, SeverityLevel severity, DateTime? time = null)
{
if (time == null)
{
time = DateTime.Now;
}
string formattedMessage =
"<log>" + Environment.NewLine +
$"\t<date>{time}</date>" + Environment.NewLine +
$"\t<level>{severity}</level>" + Environment.NewLine +
$"\t<message>{message}</message>" + Environment.NewLine +
"</log>";
return formattedMessage;
}
public void Log(SeverityLevel severity, string message, params object[] args)
{
var li = new LogItem
{
Message = string.Format(message, args),
Severity = severity,
Timestamp = DateTime.Now,
};
lock (LogItems)
{
LogItems.Add(li);
}
var ev = Logged;
if (ev != null) ev(li);
}
public void WriteMessage(string message, SeverityLevel severityLevel)
{
switch(severityLevel)
{
case SeverityLevel.MESSAGE:
MessageLevelLog.Add(message);
break;
case SeverityLevel.WARNING:
WarningLevelLog.Add(message);
break;
case SeverityLevel.ERROR:
ErrorLevelLog.Add(message);
break;
default:
return;
}
}
private string GetSeverityString(SeverityLevel severity)
{
switch (severity)
{
case SeverityLevel.Critical:
return "[CRITICAL] ";
case SeverityLevel.Error:
return "[ERROR] ";
case SeverityLevel.Warning:
return "[WARNING] ";
case SeverityLevel.Information:
return "[INFO] ";
case SeverityLevel.Verbose:
return "[DEBUG] ";
default:
throw new NotSupportedException("Unable to log severities of type " + severity + ".");
}
}
public void LogException(Exception ex, SeverityLevel severityLevel)
{
if (Log != null)
{
switch (severityLevel)
{
case SeverityLevel.Critical:
Log.Error(string.Format("{0} {1}", severityLevel.ToString().ToUpper(), ex.Message), ex);
break;
case SeverityLevel.Fatal:
Log.Fatal(string.Format("{0} {1}", severityLevel.ToString().ToUpper(), ex.Message), ex);
break;
default:
Log.Info(string.Format("{0} {1}", severityLevel.ToString().ToUpper(), ex.Message), ex);
break;
}
}
}
//***************************************************************************
// Static Methods
//
static public string GetSeverityDescription(SeverityLevel Level)
{
switch (Level)
{
case SeverityLevel.Fatal:
return "This is a non-recoverable problem.";
case SeverityLevel.Error:
return "This is a serious problem that may be recoverable.";
case SeverityLevel.Warning:
return "This is something to look into, but it probably isn't serious.";
case SeverityLevel.Information:
return "This is a general bit of application information.";
case SeverityLevel.Debug:
return "This is a note that helps track down a bug.";
default:
return "Cannot recognize the Severity Level provided!";
}
}
public void WriteMessage(string message, SeverityLevel severityLevel)
{
switch (severityLevel)
{
case SeverityLevel.MESSAGE:
Console.ForegroundColor = ConsoleColor.White;
break;
case SeverityLevel.WARNING:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case SeverityLevel.ERROR:
Console.ForegroundColor = ConsoleColor.Red;
break;
default:
Console.ForegroundColor = ConsoleColor.White;
break;
}
Console.WriteLine(DateTime.Now.ToShortDateString() + message);
}
