/// <summary>
/// Converts our severity to one of the
/// severities defined by the Windows event log
/// </summary>
/// <param name="severity">The LogEntrySeverityEnum</param>
/// <returns>A corresponding EventLogEntryType severity</returns>
private EventLogEntryType convertSeverity(LogEntrySeverityEnum severity)
{
switch (severity)
{
case LogEntrySeverityEnum.Debug:
return(EventLogEntryType.Information);
case LogEntrySeverityEnum.Error:
return(EventLogEntryType.Error);
case LogEntrySeverityEnum.Warning:
return(EventLogEntryType.Warning);
case LogEntrySeverityEnum.Success:
return(EventLogEntryType.SuccessAudit);
case LogEntrySeverityEnum.Failure:
return(EventLogEntryType.FailureAudit);
default:
// If we have anything undefined,
// treat it like the sky is falling
// down
return(EventLogEntryType.Error);
}
}
/// <summary>
/// Writes the message to the event log and sets
/// the corresponding severity
/// </summary>
/// <param name="message">The message text to write to the log</param>
/// <param name="severity">The severity for the entry</param>
public void Write(string message, LogEntrySeverityEnum severity)
{
EventLog.WriteEntry(
_source,
message,
convertSeverity(severity)
);
}
private bool willLog(LogEntrySeverityEnum severity)
{
if ((_loggableSeverities & (int)severity) > 0)
{
return(true);
}
return(false);
}
/// <summary>
/// This method will write the message to the log
/// along with select attributes from the type object
/// </summary>
/// <param name="message">The message to write to the log</param>
/// <param name="severity">The severity of the event</param>
/// <param name="type">The type object</param>
public void Write(string message, LogEntrySeverityEnum severity, Type type)
{
try
{
write(format(message, type), severity);
}
catch (Exception)
{
}
}
public virtual bool WillLog(LogEntrySeverityEnum severity)
{
try
{
return(willLog(severity));
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// This method will write the message to the log
/// along with select attributes from the exception object
/// </summary>
/// <param name="message">The message to write to the log</param>
/// <param name="severity">The severity of the event</param>
/// <param name="exception">The exception object</param>
public void Write(string message, LogEntrySeverityEnum severity, Exception exception)
{
try
{
write(format(message, exception), severity);
}
catch (Exception)
{
// Log failures should not
// cause our program to crash
}
}
/// <summary>
/// This method will write the message to the
/// log along with the corresponding severity
/// </summary>
/// <param name="message">The message to write to the log</param>
/// <param name="severity">The severity of the log entry</param>
public override void Write(string message, LogEntrySeverityEnum severity)
{
try
{
write(message, severity);
}
catch (Exception)
{
// Log failures should not
// cause our program to crash
}
}
/// <summary>
/// This method will write the message to the log
/// along with select attributes from the exception object
/// and the type object
/// </summary>
/// <param name="message">The message to write to the log</param>
/// <param name="severity">The severity of the event</param>
/// <param name="type">the type object</param>
/// <param name="exception">The exception object</param>
public void Write(string message, LogEntrySeverityEnum severity, Type type, Exception exception)
{
try
{
// Format the object type into the message
string formattedMessage = format(message, type);
// Decorate with the exception, then write it out
write(format(formattedMessage, exception), severity);
}
catch (Exception)
{
}
}
public override void Write(string message, LogEntrySeverityEnum severity, Exception exception)
{
try
{
if (_logs.Count > NUMBER_OF_LOGS_TO_KEEP)
{
_logs.TryDequeue(out string throwAway);
}
_logs.Enqueue(format(message, exception));
}
catch (Exception)
{
//Swallow
}
}
/// <summary>
/// Writes the actual data to the log.
/// </summary>
/// <param name="message">The text to log</param>
/// <param name="severity">The severity of the log entry</param>
private void write(string message, LogEntrySeverityEnum severity)
{
try
{
validateEventSource();
// Only write the entry if it meets our threshold
if ((_loggableSeverities & (int)severity) > 0)
{
Trace.WriteLine(message);
Trace.Flush();
_logWriter.Write(message, severity);
}
}
catch (Exception)
{
// Log failures should not
// cause our program to crash
}
}
public void SetLoggableSeverities(LogEntrySeverityEnum severityMask)
{
}
public override bool WillLog(LogEntrySeverityEnum severity)
{
return(true);
}
public void Write(string message, LogEntrySeverityEnum severity, Exception exception)
{
}
/// <summary>
/// Writes the actual data to the log.
/// </summary>
/// <param name="message">The text to log</param>
/// <param name="severity">The severity of the log entry</param>
private void write(string message, LogEntrySeverityEnum severity)
{
Context.WriteLine("[" + DateTime.Now + "]" + message);
}
public bool WillLog(LogEntrySeverityEnum severity)
{
return(false);
}
public void Write(string message, LogEntrySeverityEnum severity)
{
}
public abstract void Write(string message, LogEntrySeverityEnum severity);
protected void log(string message, LogEntrySeverityEnum severity)
{
TestLog.Write(message, severity);
}
public virtual void SetLoggableSeverities(LogEntrySeverityEnum severityMask)
{
_loggableSeverities = (int)severityMask;
}
