public void TestWriteEventLogEntryToSyslog(EventLogLevel severity)
{
var mockSyslogMessageWriter = new Mock <ISyslogMessageWriter>(MockBehavior.Strict);
var syslogWriter = new EventLogSyslogWriter(mockSyslogMessageWriter.Object)
{
InstallFolder = @"C:\InstallFolder",
ApplicationName = "AppName",
DatabaseName = "DbName",
DatabaseServer = "DbServerName",
EnterpriseId = 11111,
SoftwareVersion = "1.0",
ErrorEnabled = severity == EventLogLevel.Error,
InformationEnabled = severity == EventLogLevel.Information,
WarningEnabled = severity == EventLogLevel.Warning,
TraceEnabled = severity == EventLogLevel.Trace
};
var logEntry = new EventLogEntry(Guid.NewGuid(), DateTime.Now, Stopwatch.GetTimestamp(), severity, "MachineName", "ProcessName", 10, "MsgSource", "Test Message", 5555,
"FRED", "Bob");
mockSyslogMessageWriter.Setup(w => w.Write(It.Is <SyslogMessage>(m => ValidateMessage(syslogWriter, m, logEntry))));
syslogWriter.WriteEntry(logEntry);
mockSyslogMessageWriter.VerifyAll();
}
/// <summary>
/// Writes the specified message using the specified level.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="message">The message.</param>
/// <param name="parameters">The parameters.</param>
private void Write(EventLogLevel level, string message, params object[] parameters)
{
string source;
if (!CanWriteEntry(level))
{
// No writers are enabled for this level.
return;
}
if (level == EventLogLevel.Error || level == EventLogLevel.Warning || level == EventLogLevel.Information)
{
var stackFrame = new StackFrame(2);
Type reflectedType = stackFrame.GetMethod().ReflectedType;
source = reflectedType != null?string.Concat(reflectedType.FullName, "::", stackFrame.GetMethod().Name) : "(unknown)";
}
else
{
source = "(Omitted for trace messages)";
}
if (parameters == null || parameters.Length <= 0)
{
WriteEntry(level, source, message);
}
else
{
WriteEntry(level, source, string.Format(message, parameters));
}
}
public void ConstructorValidParameters( )
{
Guid id = Guid.NewGuid( );
DateTime date = DateTime.Now;
long timestamp = Stopwatch.GetTimestamp( );
const EventLogLevel logLevel = EventLogLevel.Error;
string machineName = Environment.MachineName;
string process = Process.GetCurrentProcess( ).ProcessName;
int threadId = Thread.CurrentThread.ManagedThreadId;
const string source = "Source";
const string message = "Message";
const long tenantId = 5555;
const string userName = "******";
const string tenantName = "EDC";
var entry = new EventLogEntry(id, date, timestamp, logLevel, machineName, process, threadId, source, message, tenantId, tenantName, userName);
Assert.AreEqual(id, entry.Id, "The Id is invalid");
Assert.AreEqual(date, entry.Date, "The Date is invalid");
Assert.AreEqual(timestamp, entry.Timestamp, "The Timestamp is invalid");
Assert.AreEqual(logLevel, entry.Level, "The Level is invalid");
Assert.AreEqual(machineName, entry.Machine, "The Machine is invalid");
Assert.AreEqual(process, entry.Process, "The Process is invalid");
Assert.AreEqual(threadId, entry.ThreadId, "The ThreadId is invalid");
Assert.AreEqual(source, entry.Source, "The Source is invalid");
Assert.AreEqual(tenantId, entry.TenantId, "The TenantId is invalid");
Assert.AreEqual(tenantName, entry.TenantName, "The TenantName is invalid");
Assert.AreEqual(userName, entry.UserName, "The UserName is invalid");
}
public Log(EventLogLevel minLevel = EventLogLevel.Debug, string prefix = "", ConsoleColor tagColor = ConsoleColor.White, int prefixReservedColumns = 20, TextWriter logWriter = null)
{
this.minLogLevel = minLevel;
this.prefix = prefix;
this.tagColor = tagColor;
this.prefixReservedColumns = prefixReservedColumns;
this.logWriter = logWriter;
}
public Logger(string category, EventLogLevel minLevel = EventLogLevel.Debug, string prefix = "", ConsoleColor tagColor = ConsoleColor.White, int prefixReservedColumns = 20, TextWriter logWriter = null)
{
this.category = category;
this.minLogLevel = minLevel;
this.prefix = prefix;
this.tagColor = tagColor;
this.defaultFgColor = System.Console.ForegroundColor;
this.prefixReservedColumns = prefixReservedColumns;
this.logWriter = logWriter;
}
/// <summary>
///
/// </summary>
/// <param name="level"></param>
/// <param name="category"></param>
/// <param name="message"></param>
/// <param name="skipFrames">Only relevant for level.Debug|level.Error. How many StackTrace frames to skip? If set to less than 0, will not do stack trace</param>
private void Log(EventLogLevel level, string message, int skipFrames = 1, ConsoleColor textColor = ConsoleColor.White)
{
if (level < this.minLogLevel)
{
return;
}
bool doStackTrace = false;
if (skipFrames < 0)
{
doStackTrace = false;
}
else if (level == EventLogLevel.Debug || level == EventLogLevel.Error)
{
doStackTrace = true;
}
if (doStackTrace)
{
// StackTrace output, skip first frame as that's irrelevant
StackTrace trace = new StackTrace(skipFrames, true);
StackFrame frame = trace.GetFrame(0);
string filename = frame.GetFileName();
if (filename != null)
{
filename = new FileInfo(filename).Name;
}
else
{
filename = "";
}
string traceInfo = String.Format("({0}:{1}/{2})",
filename,
frame.GetFileLineNumber(),
frame.GetMethod().Name);
this.WriteToConsole(String.Format(" {0} [{1}] {2,50} {3,10}: {4}",
DateTime.Now.ToLongTimeString(),
level,
traceInfo,
this.category,
message), textColor);
}
else
{
this.WriteToConsole(String.Format(" {0} [{1}] {2,10}: {3}",
DateTime.Now.ToLongTimeString(),
level,
this.category,
message
), textColor);
}
}
/// <summary>
/// Writes the specified entry to the event log writers,
/// </summary>
/// <param name="level">The error level.</param>
/// <param name="source">The message source.</param>
/// <param name="message">The message.</param>
private void WriteEntry(EventLogLevel level, string source, string message)
{
DiagnosticsRequestContextData context = DiagnosticsRequestContext.GetContext();
string userName = string.Empty;
long tenantId = -1;
string tenantName = string.Empty;
if (context != null)
{
userName = context.UserName;
tenantId = context.TenantId;
tenantName = context.TenantName;
}
// Truncate messages longer than 10000 chars
if (message != null && message.Length > MaximumMessageSize)
{
message = message.Substring(0, MaximumMessageSize);
}
// Create an event log entry and pass it the writers.
var logEntry = new EventLogEntry(DateTime.UtcNow,
Stopwatch.GetTimestamp(),
level,
Thread.CurrentThread.ManagedThreadId,
source ?? string.Empty,
message ?? string.Empty,
tenantId,
tenantName,
userName)
{
Machine = _machineName,
Process = _processName
};
OnWriteEvent(logEntry);
foreach (IEventLogWriter logWriter in _eventLogWriters)
{
try
{
logWriter.WriteEntry(logEntry);
}
catch (Exception ex)
{
// Prevent errors from one writer affecting others.
Trace.TraceError($"An error occured writing a message to a log writer. Writer type {logWriter.GetType().Name}, error {ex}.");
}
}
}
/// <summary>
/// Initializes a new instance of the EventLogEntry class.
/// </summary>
public EventLogEntry(DateTime date, long timestamp, EventLogLevel level, int threadId, string source, string message, long tenantId, string tenantName, string userName, string logFilePath = null)
{
_date = date;
_timestamp = timestamp;
_level = level;
_threadId = threadId;
_source = source;
_message = message;
_tenantId = tenantId;
_userName = userName;
_logFilePath = logFilePath;
_tenantName = tenantName;
}
/// <summary>
/// Initializes a new instance of the EventLogEntry class.
/// </summary>
public EventLogEntry(Guid id, DateTime date, long timestamp, EventLogLevel level, string machine, string process, int threadId, string source, string message, long tenantId, string tenantName, string userName, string logFilePath = null)
{
_id = id;
_date = date;
_timestamp = timestamp;
_level = level;
_machine = machine;
_process = process;
_threadId = threadId;
_source = source;
_message = message;
_tenantId = tenantId;
_userName = userName;
_logFilePath = logFilePath;
_tenantName = tenantName;
}
public void NewEventLog(EventLogLevel level, string code, string title, string reference, string detail, DateTime?eventDateTime = null)
{
eventDateTime = eventDateTime ?? DateTime.Now;
Console.WriteLine(title);
var newEventLog = new EventLog()
{
Id = Guid.NewGuid(),
Code = code.PadLeft(5, '0'),
Title = title,
Reference = reference,
Detail = detail,
Level = level,
EventDateTime = eventDateTime ?? DateTime.Now
};
this.erpNodeDBContext.EventLogs.Add(newEventLog);
this.erpNodeDBContext.SaveChanges();
}
/// <summary>
/// Converts the event log severity to a syslog severity.
/// </summary>
/// <param name="level">The error level.</param>
/// <returns></returns>
private SyslogSeverity ConvertToSyslogSeverity(EventLogLevel level)
{
switch (level)
{
case EventLogLevel.Error:
return(SyslogSeverity.Error);
case EventLogLevel.Information:
return(SyslogSeverity.Informational);
case EventLogLevel.Trace:
return(SyslogSeverity.Debug);
case EventLogLevel.Warning:
return(SyslogSeverity.Warning);
default:
return(SyslogSeverity.Informational);
}
}
/// <summary>
/// Returns true if the specified error level can be written, false otherwise.
/// </summary>
/// <param name="level">The error level.</param>
/// <returns></returns>
private bool CanWriteEntry(EventLogLevel level)
{
bool canWriteEntry = false;
if ((level == EventLogLevel.Error) && (_errorEnabled))
{
canWriteEntry = true;
}
else if ((level == EventLogLevel.Warning) && (_warningEnabled))
{
canWriteEntry = true;
}
else if ((level == EventLogLevel.Information) && (_informationEnabled))
{
canWriteEntry = true;
}
else if ((level == EventLogLevel.Trace) && (_traceEnabled))
{
canWriteEntry = true;
}
return(canWriteEntry);
}
public int GetAmount(EventLogLevel level)
{
return(erpNodeDBContext.EventLogs.Where(ev => ev.Level == level).Count());
}
