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()); }