public static void RecordEvent(string eventSource, LogEventType eventType, string eventMessage)
{
if (!dicInitializationState.ContainsKey(eventSource) || !dicInitializationState[eventSource])
{
Initialize(eventSource);
}
if (DateTime.Now.Day != dicLoggingDate[eventSource].Day)
{
ReopenLoggingStream(eventSource);
}
string eventTypeString = GetEventTypeString(eventType);
try
{
string logEntry = string.Format
(
"{0} [{1}]{2}{3}\r\n",
DateTime.Now.ToString(eventDateTimeFormat),
eventTypeString,
string.Empty.PadRight(eventTypeColumnWidth - eventTypeString.Length),
eventMessage
);
WriteStringToLogFile(eventSource, logEntry);
}
catch (Exception ex)
{
Trace.WriteLine(string.Format("Failed to record event: {0}", ex));
}
}
public void Log(LogEventType et, string message)
{
LastMessage =
"[{0:dd.MM.yyyy HH:mm:ss}] {1}".FormatStr(DateTime.Now, message);
if (OnLog != null)
OnLog(this, new LogEventArgs(this, new LogItem(et, LastMessage)));
}
public Logger(IEnumerable<TextWriter> logWriters, IEnumerable<TextWriter> errorWriters,
LogEventType lowestEventTypeForWorkflowLog = LogEventType.Information,
LogEventType lowestEventTypeForWorkflowError = LogEventType.Warning) : this(false, lowestEventTypeForWorkflowLog, lowestEventTypeForWorkflowError)
{
_logWriters.AddRange(logWriters);
_errorWriters.AddRange(errorWriters);
}
public LogEvent(string ipAddress, string user, string topic, LogEventType type, ILogSink sink)
{
IP = ipAddress;
User = user;
Topic = topic;
Type = type;
Sink = sink;
}
/// <summary>
/// Initializes a new instance of the LoggerEntry class.
/// </summary>
/// <param name="context"></param>
public LogEntry(LogEventType eventType, string source, int id, string format, params object[] data)
{
_eventType = eventType;
_source = source;
_id = id;
_format = format;
_data = data;
}
/// <summary>
/// Logs the specified event.
/// </summary>
/// <param name="logEvent">The event (object) to log.</param>
/// <param name="type">Event type</param>
public static void Log(object logEvent, LogEventType type = LogEventType.Information)
{
if (Loggers == null) return;
foreach (var logger in Loggers)
if (logger.TypeFilter == LogEventType.Undefined || ((logger.TypeFilter & type) == type))
logger.Log(logEvent, type);
}
public LogEvent CreateEvent(string ipAddress, string user, string topic, LogEventType type)
{
lock (_lock)
{
LogEvent answer = new LogEvent(ipAddress, user, topic, type, _sink);
return answer;
}
}
public LogEvent(String sourceName, Object sender, BuildEventArgs args, LogEventType eventType)
{
_sourceName = sourceName;
_sender = sender;
_args = args;
_eventType = eventType;
_exception = null;
}
public static void Log(
this IServiceProvider provider,
LogEventType eventType,
string message)
{
var svc = provider.GetService<ILogger>();
svc?.Log(eventType, message);
}
public static void Logging(LogEventType let, string message, string errorStackTrace, string errorParam)
{
var l = new LogEvent();
l.EventType = let;
l.Message = message;
l.ErrorStackTrace = errorStackTrace;
l.ErrorParam = errorParam;
l.Insert();
}
public static void RecordLog(string title,
LogEventType eventType,
LogPriority priority,
object extraObject,
System.Exception e)
{
LogManager lm = new LogManager();
lm.Record(title, eventType, priority, extraObject, e);
}
/// <summary>
/// Adds a new event to the event log for the current date/time.
/// </summary>
/// <param name="level">The log event level.</param>
/// <param name="type">The log event type.</param>
/// <param name="source">The event source.</param>
/// <param name="message">The event message.</param>
/// <param name="parameters">The event parameters.</param>
/// <param name="exception">The event exception.</param>
/// <param name="subevents">The list of subevents.</param>
/// <returns>The log event.</returns>
public LogEvent Add(
LogEventLevel level,
LogEventType type,
string source,
string message,
object[] parameters = null,
Exception exception = null,
List<LogEvent> subevents = null
)
{
LogEvent evt;
// Create the event.
evt = new LogEvent(level, type, DateTime.Now, source, message, parameters, exception, subevents);
// Compute the file name.
string fileName = string.Format(this.filePattern, evt.Timestamp.ToUniversalTime().Year, evt.Timestamp.ToUniversalTime().Month, evt.Timestamp.ToUniversalTime().Day);
try
{
XDocument xml;
// Check whether there exists a file for the event date.
if (!this.logs.TryGetValue(evt.Timestamp.Date, out xml))
{
// If the file exists.
if (File.Exists(fileName))
{
// Read the XML from the file.
try { xml = XDocument.Load(fileName); }
catch (Exception) { xml = new XDocument(new XElement("log", new XAttribute("date", evt.Timestamp.ToUniversalTime().Date.ToString(CultureInfo.InvariantCulture)))); }
}
else
{
// Create a new empty XML.
xml = new XDocument(new XElement("log", new XAttribute("date", evt.Timestamp.ToUniversalTime().Date.ToString(CultureInfo.InvariantCulture))));
}
// Add the XML to the logs list.
this.logs.Add(evt.Timestamp.Date, xml);
}
// Add the event to the XML file.
xml.Root.Add(evt.Xml);
}
catch (Exception ex)
{
evt.Logger = string.Format("Could not save the event {0} to the log \"{1}\" ({2}).", evt.Timestamp, fileName, ex.Message);
}
// Raise the event for this log event.
if (this.EventLogged != null) this.EventLogged(this, new LogEventArgs(evt));
return evt;
}
private void LogEvent(string username, string message, LogEventType logEvent)
{
DateTime now = DateTime.Now;
LogModel logModel = new LogModel();
string combinedMessage = message + " for user: " + username;
logModel.date = now;
logModel.description = combinedMessage;
logModel.Username = username;
logModel.logEvent = logEvent;
db.Logs.Add(logModel);
db.SaveChanges();
}
public void WriteEvent(LogEventType type, string message, int indent = 0)
{
using (FileStream fs = getLogFile())
{
using (var writer = new StreamWriter(fs))
{
var now = DateTime.Now;
writer.Write("===========[BeginLogEvent:{0} on {1}]===========\n", type.ToString(), now);
for (int i = 0; i < indent; i++)
writer.Write("\t");
writer.Write(message);
writer.Write("\n-----------[EndLogEvent:{0} on {1}]-----------\n", type.ToString(), now);
}
}
}
public static void LogThis(string ErrorMessage, LogEventType LogEvent, string BadgeNumber, string AgencyName)
{
bool LogMessage = true;
switch ( LogEvent)
{
case LogEventType.Error:
break;
case LogEventType.Warning:
break;
case LogEventType.Info:
break;
case LogEventType.InMessages:
LogMessage = false;
break;
case LogEventType.OutMessages:
LogMessage = false;
break;
case LogEventType.MessagePath:
LogMessage = false;
break;
}
if (LogMessage == false)
return;
try
{
if (ErrorMessage.Length > 1000)
ErrorMessage = ErrorMessage.Substring(0, 999);
if (BadgeNumber.Length > 23)
BadgeNumber = BadgeNumber.Substring(0, 22);
if (AgencyName.Length > 60)
AgencyName = AgencyName.Substring(0, 59);
AgencyName = "";
string SQL = "INSERT INTO i9SysLog (LogDateTime, LogDescription, LogType, AgencyName, BadgeNumber) VALUES ('" + DateTime.Now.ToString() + "', " + SQLUtility.SQLString(ErrorMessage) + ", " + SQLUtility.SQLString(LogEvent.ToString()) + ", " + SQLUtility.SQLString(AgencyName) + ", " + SQLUtility.SQLString(BadgeNumber) + ")";
SQLAccess da = new SQLAccess();
da.ExecuteSQL(SQL);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Logs the specified exception.
/// </summary>
/// <param name="leadingText">The leading text (inserted before the actual exception detail).</param>
/// <param name="exception">The exception.</param>
/// <param name="type">Event type</param>
public static void Log(string leadingText, Exception exception, LogEventType type = LogEventType.Exception)
{
if (Loggers == null) return;
var exceptionText = leadingText + "\r\n\r\n" + ExceptionHelper.GetExceptionText(exception);
foreach (var logger in Loggers)
if (logger.TypeFilter == LogEventType.Undefined || ((logger.TypeFilter & type) == type))
{
var exceptionLogger = logger as IExceptionLogger;
if (exceptionLogger != null)
exceptionLogger.Log(leadingText, exception, type);
else
logger.Log(exceptionText, type);
}
}
/// <summary>
/// Logs the specified event (text).
/// </summary>
/// <param name="logEvent">The event (text).</param>
/// <param name="type">The event type.</param>
/// <remarks>
/// Log types are mapped to the following system event types (in this order):
/// LogEventType.Critical = EventLogEntryType.Error
/// LogEventType.Error = EventLogEntryType.FailureAudit
/// LogEventType.Exception = EventLogEntryType.FailureAudit
/// LogEventType.Warning = EventLogEntryType.Warning
/// LogEventType.Success = EventLogEntryType.SuccessAudit
/// other: = EventLogEntryType.Information
/// </remarks>
public override void Log(string logEvent, LogEventType type)
{
if (_recipients.Count == 0) throw new ArgumentOutOfRangeException("You must specify at least 1 recipient email address");
var subject = Enum.GetName(typeof(LogEventType), type) + ": Log Entry for " + _appName;
ThreadPool.QueueUserWorkItem(c =>
{
foreach (var recipient in _recipients)
{
try
{
EmailHelper.SendEmail(_senderName, _senderEmail, recipient.Name, recipient.EmailAddress, subject, logEvent,
null, _mailServer, _portNumber, _userName, _password);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ExceptionHelper.GetExceptionText(ex));
}
}
});
}
public Logger(bool includeStandardOutput = true, LogEventType lowestEventTypeForWorkflowLog = LogEventType.Information, LogEventType lowestEventTypeForWorkflowError = LogEventType.Warning)
{
if (includeStandardOutput)
{
_logWriters.Add(Console.Out);
_errorWriters.Add(Console.Error);
}
if (lowestEventTypeForWorkflowError <= lowestEventTypeForWorkflowLog)
throw new ArgumentException("Lowest severity level for error log must be greater than lowest severity level for standard log");
_lowestEventTypeForWorkflowLog = lowestEventTypeForWorkflowLog;
_lowestEventTypeForWorkflowError = lowestEventTypeForWorkflowError;
//make sure
_cancellationTokenSource.Token.Register(() => _readyToFlushLog.TrySetResult(true));
_cancellationTokenSource.Token.Register(() => _readyToFlushError.TrySetResult(true));
//start our logging tasks
_logTask = RunLogger(true);
_errorTask = RunLogger(false);
}
private static string GetEventTypeString(LogEventType eventType)
{
string result;
switch (eventType)
{
case LogEventType.Trace:
result = "TRACE";
break;
case LogEventType.Warning:
result = "WARNING";
break;
case LogEventType.Error:
result = "ERROR";
break;
case LogEventType.Exception:
result = "EXCEPTION";
break;
default:
result = "INFO";
break;
}
return result;
}
/// <summary>
/// 记录流程异常日志
/// </summary>
/// <param name="entity"></param>
public void Record(string title,
LogEventType eventType,
LogPriority priority,
object extraObject,
System.Exception e)
{
try
{
var log = new LogEntity();
log.EventTypeID = (int)eventType;
log.Priority = (int)priority;
log.Severity = priority.ToString().ToUpper();
log.Title = title;
log.Timestamp = DateTime.Now;
log.Message = e.Message;
log.StackTrace = e.StackTrace.Length > 4000 ? e.StackTrace.Substring(0, 4000): e.StackTrace;
if (e.InnerException != null)
{
log.InnerStackTrace = e.InnerException.StackTrace.Length > 4000 ?
e.InnerException.StackTrace.Substring(0, 4000) : e.InnerException.StackTrace;
}
if (extraObject != null)
{
var jsonData = JsonSerializer.SerializeToString(extraObject);
log.RequestData = jsonData.Length > 2000 ? jsonData.Substring(0, 2000) : jsonData;
}
//线程池添加日志记录
ThreadPool.QueueUserWorkItem(new WaitCallback(Insert), log);
}
catch
{
//如果记录日志发生异常，不做处理
;
}
}
/// <summary>
/// Logs an event to the ILogTarget
/// </summary>
/// <param name="eventType">LogEventType of the event</param>
/// <param name="message">corresponding message</param>
public static void LogEvent(LogEventType eventType, string message)
{
if (Properties.Settings.Default.USER_LOGGING_ENABLED)
{
if (!HasValidTarget())
throw new LoggingException(ERROR_TARGET_NULL);
if (_builder == null)
_builder = new StringBuilder();
else
_builder.Clear();
_builder.Append('[' + eventType.ToString() + ']');
if (_writeTime)
_builder.Append('[' + DateTime.Now.ToLongTimeString() + ']');
else
_builder.Append('\t');
_builder.Append("\t" + message);
WriteToTargets(_builder.ToString());
}
}
public void WriteEvent(string eventName, LogEventSeverity eventSeverity, LogEventType eventType, params KeyValuePair <string, object>[] properties)
{
WriteEvent(eventName, eventSeverity, eventType, null, properties);
}
public void WriteEventWithSource(string eventName, LogEventSeverity eventSeverity = LogEventSeverity.Information, LogEventType eventType = LogEventType.ApplicationEvent,
Exception exception = null,
#if SUPPORTS_CALLERATTRIBUTES
[System.Runtime.CompilerServices.CallerFilePath]
#endif
string source = null,
#if SUPPORTS_CALLERATTRIBUTES
[System.Runtime.CompilerServices.CallerMemberName]
#endif
string sourceMethod = null,
#if SUPPORTS_CALLERATTRIBUTES
[System.Runtime.CompilerServices.CallerLineNumber]
#endif
int sourceLineNumber = -1,
params KeyValuePair <string, object>[] properties)
{
WriteEventWithExplicitSource(eventName, eventSeverity, eventType, source, sourceMethod, sourceLineNumber, properties, exception);
}
/// <summary>
/// Create a log message
/// </summary>
/// <param name="severity">Controls if and where the message is logged</param>
/// <param name="message"></param>
/// <param name="source"></param>
/// <param name="exception"></param>
/// <param name="addTag">Prepend severity info to message? Default if severity >= Warning</param>
public LogEntry(LogEventType severity, string message, string source,
Exception exception, bool? addTag=null)
{
if (string.IsNullOrEmpty(message))
throw new ArgumentException($"{nameof(message)} cannot be null or empty");
if (severity < LogEventType.Debug || severity > LogEventType.Critical)
throw new ArgumentOutOfRangeException(nameof(severity));
this.Severity = severity;
if (addTag ?? (severity >= LogEventType.Warning))
this.Message = $"{severity.ToString().ToUpper()}: {message}";
else
this.Message = message;
this.Source = source;
this.Exception = exception;
}
private void WriteLog(LogEventType eventType, string msg)
{
LFactory.Instance.Write(eventType, msg);
}
private void WriteEventWithExplicitSource(string eventName, LogEventSeverity eventSeverity, LogEventType eventType, string source, string sourceMethod, int sourceLineNumber, KeyValuePair <string, object>[] properties, Exception exception)
{
try
{
if (!IsEnabled || !(_FirstChanceFilter?.ShouldLog(eventName, eventSeverity, eventType, source, sourceMethod) ?? true))
{
return;
}
using (var pooledLogEvent = _EntryPool.Take())
{
var logEvent = pooledLogEvent.Value;
InitialiseLogEvent(eventName, eventSeverity, eventType, properties, exception, logEvent);
UnsafeWriteEvent(logEvent, source, sourceMethod, sourceLineNumber);
}
}
catch (LogException lex)
{
if (_ErrorHandler.ReportError(lex) == LoggingErrorPolicy.Rethrow)
{
throw;
}
}
catch (Exception ex) when(!ex.ShouldRethrowImmediately())
{
var wrappedException = new LogException(ex.Message, ex);
if (_ErrorHandler.ReportError(wrappedException) == LoggingErrorPolicy.Rethrow)
{
throw wrappedException;
}
}
}
private void InitialiseLogEvent(string eventName, LogEventSeverity eventSeverity, LogEventType eventType, KeyValuePair <string, object>[] properties, Exception exception, LogEvent logEvent)
{
logEvent.DateTime = _LogClock.Now;
logEvent.EventName = eventName ?? String.Empty;
logEvent.EventSeverity = eventSeverity;
logEvent.EventType = eventType;
logEvent.Exception = exception;
RenderProperties(properties, logEvent);
}
public static void Trace(this ILogger log, LogEventType type, Exception err)
{
log.Trace(type, err, null);
}
public static void Trace(this ILogger log, LogEventType type, string format, params object[] args)
{
if (log != null)
log.Write(type, 0, format, args);
}
public static void Trace(this ILogger log, LogEventType type, Exception err, string message)
{
if (log != null && log.ShouldTrace(type))
log.Trace(LogEventType.Error,
(new StringBuilder()).Append(message ?? "Exception").Append(" : ").FormatException(err).ToString());
}
public static void Trace(this ILogger log, LogEventType type, string message)
{
if (log != null)
log.Write(type, 0, message);
}
// Log.
/// <summary>
/// Logs an event for the specified toolset.
/// </summary>
/// <param name="level">The log event level.</param>
/// <param name="type">The log event type.</param>
/// <param name="message">The event message.</param>
/// <param name="parameters">The event parameters.</param>
/// <param name="exception">The event exception.</param>
public LogEvent Log(LogEventLevel level, LogEventType type, string message, object[] parameters = null, Exception exception = null)
{
return this.application.Log.Add(
level,
type,
@"Toolbox\{0}\{1}".FormatWith(this.toolset.Name, this.tool.Name),
message,
parameters,
exception
);
}
/// <summary>
/// Serializes the exception and returns the serialzied text
/// </summary>
/// <param name="exception">The exception.</param>
/// <param name="type">The log info type.</param>
/// <returns>Serialized exception information</returns>
/// <remarks>This method is designed to be overridden in subclasses</remarks>
protected virtual string GetSerializedExceptionText(Exception exception, LogEventType type)
{
return ExceptionHelper.GetExceptionText(exception);
}
/// <summary>
/// Logs the specified event (text).
/// </summary>
/// <param name="logEvent">The event (text).</param>
/// <param name="type">The event type.</param>
/// <remarks>
/// Milos log types are mapped to the following system event types (in this order):
/// LogEventType.Critical = EventLogEntryType.Error
/// LogEventType.Error = EventLogEntryType.FailureAudit
/// LogEventType.Exception = EventLogEntryType.FailureAudit
/// LogEventType.Warning = EventLogEntryType.Warning
/// LogEventType.Success = EventLogEntryType.SuccessAudit
/// other: = EventLogEntryType.Information
/// </remarks>
public override void Log(string logEvent, LogEventType type)
{
// We make sure the source exists
if (!EventLog.SourceExists(InternalEventLog.Source, InternalEventLog.MachineName))
EventLog.CreateEventSource(new EventSourceCreationData(InternalEventLog.Source, InternalEventLog.Log) {MachineName = InternalEventLog.MachineName});
// We are ready to log the event
if (type == LogEventType.Undefined)
InternalEventLog.WriteEntry(logEvent);
else
{
EventLogEntryType systemType;
if ((type & LogEventType.Critical) == LogEventType.Critical) systemType = EventLogEntryType.Error;
else if (((type & LogEventType.Error) == LogEventType.Error) || ((type & LogEventType.Exception) == LogEventType.Exception)) systemType = EventLogEntryType.FailureAudit;
else if ((type & LogEventType.Warning) == LogEventType.Warning) systemType = EventLogEntryType.Warning;
else if ((type & LogEventType.Success) == LogEventType.Success) systemType = EventLogEntryType.SuccessAudit;
else systemType = EventLogEntryType.Information;
InternalEventLog.WriteEntry(logEvent, systemType);
}
}
public void WriteEvent(string eventName, LogEventSeverity eventSeverity, LogEventType eventType, Exception exception, params KeyValuePair <string, object>[] properties)
{
WriteEventWithExplicitSource(eventName, eventSeverity, eventType, null, null, -1, properties, exception);
}
