private static EventLogEntryType EventLogEntryTypeFromEventType(TraceEventType type) { EventLogEntryType eventLogEntryType = EventLogEntryType.Information; TraceEventType traceEventType = type; switch (traceEventType) { case TraceEventType.Critical: case TraceEventType.Error: { eventLogEntryType = EventLogEntryType.Error; return eventLogEntryType; } case TraceEventType.Critical | TraceEventType.Error: { return eventLogEntryType; } case TraceEventType.Warning: { eventLogEntryType = EventLogEntryType.Warning; return eventLogEntryType; } default: { return eventLogEntryType; } } }
public void AddNewItemToTraceList(TraceEventType eventType, string message) { LogEntry leNewTraceItem = new LogEntry(); leNewTraceItem.Message = message; leNewTraceItem.Severity = eventType; leNewTraceItem.TimeStamp = DateTime.Now; lock (lockObject) { lstFreshTrace.Add(leNewTraceItem); if ( eventType == TraceEventType.Critical || eventType == TraceEventType.Error || eventType == TraceEventType.Warning ) { lstFreshTraceErrors.Add(leNewTraceItem); } if ( lstFreshTraceErrors.Count > errorsNumber ) { lstFreshTraceErrors.RemoveAt(0); } if (lstFreshTrace.Count > infoNumber) { lstFreshTrace.RemoveAt(0); } } }
LoggingLevel(string name, int index, SourceLevels sourceLevel, TraceEventType traceEventType) { _name = name; _index = index; _sourceLevel = sourceLevel; _traceEventType = traceEventType; }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message) { if ((this.Filter == null) || this.Filter.ShouldTrace(eventCache, source, eventType, id, message, null, null, null)) { this.WriteLine(message); } }
static Level DefaultGetLogLevel(TraceEventType traceEventType) { switch (traceEventType) { case TraceEventType.Critical: return Level.Fatal; case TraceEventType.Error: return Level.Error; case TraceEventType.Warning: return Level.Warn; case TraceEventType.Information: return Level.Info; case TraceEventType.Verbose: return Level.Trace; case TraceEventType.Start: return Level.Debug; case TraceEventType.Stop: return Level.Debug; case TraceEventType.Suspend: return Level.Debug; case TraceEventType.Resume: return Level.Debug; case TraceEventType.Transfer: return Level.Debug; default: throw new ArgumentOutOfRangeException("traceEventType"); } }
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data) { tracedData = data; tracedSource = source; tracedEventType = eventType; entries.Add(data as LogEntry); }
private static LogLevels? ToStockSharp(TraceEventType eventType) { switch (eventType) { case TraceEventType.Critical: case TraceEventType.Error: return LogLevels.Error; case TraceEventType.Warning: return LogLevels.Warning; case TraceEventType.Information: return LogLevels.Info; case TraceEventType.Verbose: return LogLevels.Debug; case TraceEventType.Start: case TraceEventType.Stop: case TraceEventType.Suspend: case TraceEventType.Resume: case TraceEventType.Transfer: return null; default: throw new ArgumentOutOfRangeException("eventType"); } }
private EtwEventLevel ConvertTraceEventTypeToEventLevel(TraceEventType eventType) { EtwEventLevel verbose = EtwEventLevel.Verbose; switch (eventType) { case TraceEventType.Critical: return EtwEventLevel.Critical; case TraceEventType.Error: return EtwEventLevel.Error; case (TraceEventType.Error | TraceEventType.Critical): return verbose; case TraceEventType.Warning: return EtwEventLevel.Warning; case TraceEventType.Information: return EtwEventLevel.Information; case TraceEventType.Verbose: return EtwEventLevel.Verbose; } return verbose; }
public void Log(string message, TraceEventType eventType) { foreach (ILogger logger in this.loggers) { logger.Log(message, eventType); } }
internal bool ShouldLog(TraceEventType severity, LogPriority priority, IEnumerable<LogCategory> categories) { return ShouldLog(severity, "All") || ShouldLog(severity, priority.ToString()) || categories.Any(c => ShouldLog(severity, c.ToString())); }
protected static bool DefaultIsLogEventEnabled(ILog commonLog, TraceEventType traceEventType) { switch (traceEventType) { case TraceEventType.Critical: return commonLog.IsFatalEnabled; case TraceEventType.Error: return commonLog.IsErrorEnabled; case TraceEventType.Warning: return commonLog.IsWarnEnabled; case TraceEventType.Information: return commonLog.IsInfoEnabled; case TraceEventType.Verbose: return commonLog.IsTraceEnabled; case TraceEventType.Start: return commonLog.IsDebugEnabled; case TraceEventType.Stop: return commonLog.IsDebugEnabled; case TraceEventType.Suspend: return commonLog.IsDebugEnabled; case TraceEventType.Resume: return commonLog.IsDebugEnabled; case TraceEventType.Transfer: return commonLog.IsDebugEnabled; default: throw new ArgumentOutOfRangeException("traceEventType"); } }
LogLevel(string name, int index, SourceLevels sourceLevel, TraceEventType traceEventType) { Name = name; _index = index; SourceLevel = sourceLevel; TraceEventType = traceEventType; }
void Trace(TraceEventType eventType, string message) { if (this.Switch.ShouldTrace(eventType) && this.Listeners != null) { TraceEvent(eventType, 0, m_header + message); } }
internal MyLoggingExceptionHandler(string logCategory, int eventId, TraceEventType severity, string title, int priority, Type formatterType, LogWriter writer, DocumentModel doc) : base(logCategory, eventId, severity, title, priority, formatterType, writer) { this.m_Writer = writer; this.doc = doc; }
private LogLevel Map(TraceEventType eventType) { switch (eventType) { case TraceEventType.Critical: return LogLevel.Fatal; case TraceEventType.Error: return LogLevel.Error; case TraceEventType.Warning: return LogLevel.Warn; case TraceEventType.Information: return LogLevel.Info; case TraceEventType.Verbose: return LogLevel.Trace; case TraceEventType.Start: return LogLevel.Info; case TraceEventType.Stop: return LogLevel.Info; case TraceEventType.Suspend: return LogLevel.Info; case TraceEventType.Resume: return LogLevel.Info; case TraceEventType.Transfer: return LogLevel.Info; default: throw new ArgumentOutOfRangeException("eventType"); } }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message) { try { var dict = message.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) .Select(part => part.Split('=')) .ToDictionary(split => split[0], split => split[1]); string iid; if (dict.TryGetValue("iid", out iid)) { string toWrite = string.Format("[{0} {1}] {2}", DateTime.Now, iid, dict["msg"]); base.WriteLine(toWrite); } else { string toWrite = string.Format("[{0}] {1}", DateTime.Now, dict["msg"]); base.WriteLine(toWrite); } } catch (Exception exception) { string toWrite = string.Format("Exception while parsing trace: {0}\n\t", exception.Message, exception.StackTrace); base.WriteLine(toWrite); } }
private static EventLevel GetLogLevel(TraceEventType traceEventType) { switch (traceEventType) { case TraceEventType.Critical: return EventLevel.Critical; case TraceEventType.Error: return EventLevel.Error; case TraceEventType.Warning: return EventLevel.Warning; case TraceEventType.Information: return EventLevel.Informational; case TraceEventType.Verbose: case TraceEventType.Start: case TraceEventType.Stop: case TraceEventType.Suspend: case TraceEventType.Resume: case TraceEventType.Transfer: return EventLevel.Verbose; default: throw new ArgumentOutOfRangeException(nameof(traceEventType)); } }
protected override void TraceSimpleEvent(DateTime eventTime, Int32 threadId, TraceEventType eventType, String message, Int32 eventId, TraceEventCache eventCache, String source) { if (this._traceListener != null) { this._traceListener.TraceEvent(eventCache, source, eventType, eventId, message); } }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args) { if (Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, format, args, null, null)) { return; } var client = new SmtpClient(Settings.Default.SmtpServer) { Credentials = new NetworkCredential(Settings.Default.SmtpUsername, Settings.Default.SmtpPassword), EnableSsl = true }; var body = string.Format(format, args); var firstLine = new StringReader(body).ReadLine(); if (firstLine.Length > 100) { firstLine = firstLine.Substring(0, 97).Trim() + "..."; } var msg = new MailMessage { From = new MailAddress(Settings.Default.NotificationFrom, "FitBot"), To = {Settings.Default.NotificationTo}, Subject = $"{eventType} - {firstLine}", Body = body }; client.Send(msg); }
public override sealed void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message) { if ((base.Filter == null) || base.Filter.ShouldTrace(eventCache, source, eventType, id, message, null, null, null)) { WriteTrace(eventCache, source, eventType, id, message, null, null); } }
/// <summary> /// /// </summary> /// <param name="severity"></param> /// <returns></returns> private Action<object, Exception> GenerateLog(TraceEventType severity) { switch (severity) { case TraceEventType.Error: return LogError.Error; case TraceEventType.Information: return LogInfo.Info; case TraceEventType.Warning: return LogWarm.Warn; case TraceEventType.Critical: break; case TraceEventType.Verbose: break; case TraceEventType.Start: break; case TraceEventType.Stop: break; case TraceEventType.Suspend: break; case TraceEventType.Resume: break; case TraceEventType.Transfer: break; default: return LogInfo.Info; } return LogInfo.Info; }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id) { var te = new TraceEvent {Cache = eventCache, Source = source, Type = eventType, Id = id}; Events.Add(te); if (OnEventAdd != null) OnEventAdd.Invoke(te); }
/// <summary> /// Determines whether a filter is attached to this listener and, if so, asks whether it ShouldTrace applies to this data. /// </summary> protected virtual bool ShouldTrace(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string formatOrMessage, object[] args, object data1, object[] data) { return !(Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, formatOrMessage, args, data1, data)); }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id) { this.source = source; this.eventType = eventType; this.id = id; TraceEvent(eventCache, source, eventType, id, "No additional information."); }
public DebugConsoleMessageEventArgs(DateTime timestamp, string message, TraceEventType level, string source) { Timestamp = timestamp; Message = message; Level = level; Source = source; }
private void Trace(TraceEventType type, string message, params object[] parameters) { if (category.Source.Switch.ShouldTrace(type)) { category.Source.TraceEvent(type, EVENT_ID, message, parameters); } }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id) { if (_enabled) { WebSocketHost.Send($"{eventType}:{id} - {source}"); } }
/// <summary> /// Returns the value of Environment.MachineName /// </summary> /// <param name="value">The output parameter</param> /// <param name="cache">Unused</param> /// <param name="source">Unused</param> /// <param name="eventType">Unused</param> /// <param name="id">Unused</param> /// <param name="formatOrMessage">Unused</param> /// <param name="data">Unused</param> /// <returns>True</returns> public override bool TryGetValue(out object value, TraceEventCache cache, string source, TraceEventType eventType, int id, string formatOrMessage, object[] data) { value = Environment.MachineName; return true; }
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data) { if (this.Filter != null && !this.Filter.ShouldTrace(eventCache, source, eventType, id, string.Empty, null, null, null)) return; foreach (object obj in data) { if (obj is XPathNavigator) { using (var reader = ((XPathNavigator)obj).ReadSubtree()) { reader.MoveToContent(); if (reader.IsStartElement()) Console.WriteLine(XElement.ReadFrom(reader).ToString(SaveOptions.OmitDuplicateNamespaces)); else { Console.WriteLine("Unable to write Xml data."); } } } else { Console.WriteLine(obj.ToString()); } } }
public override sealed void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data) { if ((base.Filter == null) || base.Filter.ShouldTrace(eventCache, source, eventType, id, null, null, null, data)) { WriteTrace(eventCache, source, eventType, id, null, null, data); } }
private static void WriteEvent(TraceEventType eventType, CompositionTraceId traceId, string format, params object[] arguments) { Source.TraceEvent(eventType, (int)traceId, format, arguments); }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args) { base.TraceEvent(eventCache, source, eventType, id, format, args); if (format.StartsWith("Storyboard has begun;")) { TriggerTraceStoryboard storyboard = args[1] as TriggerTraceStoryboard; if (storyboard != null) { // add a breakpoint here to see when your trigger has been // entered or exited // the element being acted upon object targetElement = args[5]; // the namescope of the element being acted upon INameScope namescope = (INameScope)args[7]; TriggerBase triggerBase = storyboard.TriggerBase; string triggerName = GetTriggerName(storyboard.TriggerBase); Debug.WriteLine(string.Format("Element: {0}, {1}: {2}: {3}", targetElement, triggerBase.GetType().Name, triggerName, storyboard.StoryboardType)); } } }
public void Log(string message, TraceEventType eventType) { }
/// <summary> /// Writes trace information, a formatted array of objects and event information to the listener specific output. /// </summary> /// <param name="eventCache">A <see cref="T:System.Diagnostics.TraceEventCache"/> object that contains the current process ID, thread ID, and stack trace information.</param> /// <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param> /// <param name="eventType">One of the <see cref="T:System.Diagnostics.TraceEventType"/> values specifying the type of event that has caused the trace.</param> /// <param name="id">A numeric identifier for the event.</param> /// <param name="format">A format string that contains zero or more format items, which correspond to objects in the <paramref name="args"/> array.</param> /// <param name="args">An object array containing zero or more objects to format.</param> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.EnvironmentPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/> /// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode"/> /// </PermissionSet> public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args) { // Call overload TraceEvent(eventCache, source, eventType, id, string.Format(format, args)); }
public void Event(TraceEventType type, TraceMessage message) { Console.WriteLine("{0} {1}", type, message); }
/// <summary> /// Indicates if the specified <paramref name="eventType"/> is enable and should produce a trace. /// </summary> /// <param name="eventType">An indication of the type of trace event.</param> /// <returns>Returns true when the specified <paramref name="eventType"/> should produce a trace.</returns> public bool ShouldTrace(TraceEventType eventType) { return(_traceSource.Switch.ShouldTrace(eventType)); }
public void Write(object message, ICollection <string> categories, int priority, int eventId, TraceEventType severity, string title, IDictionary <string, object> properties) { Entries.Add(new EventLogEntryForTests(message, categories, priority, eventId, severity, title, properties)); }
private static void Trace(TraceEventType eventType, string message) { Trace(eventType, "{0}", message); }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id) { TraceEvent(eventCache, source, eventType, id, string.Empty); }
private static void Trace(TraceEventType eventType, string format, params object[] args) { Trace(_tracer, eventType, format, args); }
public static bool IsSeverityEnabled(TraceEventType severity) { bool enabled = severity <= _minimalSeverity ? true : false; return(enabled); }
// These methods are not currently supported because they are not necessary. // However, they have sufficient parameters to properly identify the event. #region NotSupported but might be reasonable to support public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data) { throw new NotSupportedException(); }
public void Write(string title, TraceEventType traceEventType) { Write(title, null, traceEventType); }
// Write record to file static private void _CreateLogRecord(Exception ex, TraceEventType currentSeverity) { string logMessage = _GetLogMessage(ex); _CreateLogRecord(logMessage, currentSeverity); }
protected void Log(TraceEventType severity, string message, params object[] args) { OnWriteLog(severity, String.Format(CultureInfo.CurrentCulture, message, args)); }
public abstract void Log(TraceEventType logEvent);
/// <summary> /// Writes trace information, a message, and event information to the listener specific output. /// </summary> /// <param name="eventCache">A TraceEventCache object that contains the current process ID, thread ID, and stack trace information.</param> /// <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param> /// <param name="eventType">One of the TraceEventType values specifying the type of event that has caused the trace.</param> /// <param name="id">A numeric identifier for the event.</param> public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id) { this.TraceEvent(eventCache, source, eventType, id, id.ToString(CultureInfo.InvariantCulture)); }
/// <inheritdoc /> /// <remarks> /// This method calls the underlying property reader to obtain its value, and then if the obeject returned implements /// the <see cref="System.IFormattable"/> interface we then call .ToString(FormatString) on it and return the /// formatted version of the data. /// </remarks> public override bool TryGetValue(out object value, TraceEventCache cache, string source, TraceEventType eventType, int id, string formatOrMessage, object[] data) { object subval = null; if (_wrappedPropertyReader.TryGetValue(out subval, cache, source, eventType, id, formatOrMessage, data)) { value = subval; IFormattable formattable = subval as IFormattable; if (formattable != null) { value = formattable.ToString(FormatString, CultureInfo.InvariantCulture); } return(true); } value = null; return(false); }
public void Log(string message, TraceEventType eventType) { Console.WriteLine("{0:G} - {1}: {2}", DateTime.Now, eventType, message); }
protected abstract void OnWriteLog(TraceEventType severity, string message);
public static void WriteLog(int eventId, int priority, string message, string category, TraceEventType traceEventType, string moduleName) { LogEntry logEntry = new LogEntry(); logEntry.EventId = eventId; logEntry.Priority = priority; logEntry.Message = message; logEntry.Categories.Add(category); logEntry.Severity = traceEventType; logEntry.Title = moduleName; Logger.Write(logEntry); }
public virtual void Log(TraceEventType logEvent) { }
internal void LogEvent(TraceEventType type, EventLogCategory category, EventLogEventId eventId, params string[] values) { this.LogEvent(type, category, eventId, true, values); }
/// <summary> /// Initialize a new instance of a <see cref="XmlLogEntry"/> class. /// </summary> /// <param name="message"></param> /// <param name="category"></param> /// <param name="priority"></param> /// <param name="eventId"></param> /// <param name="severity"></param> /// <param name="title"></param> /// <param name="properties"></param> public XmlLogEntry(object message, ICollection <string> category, int priority, int eventId, TraceEventType severity, string title, IDictionary <string, object> properties) : base(message, category, priority, eventId, severity, title, properties) { }
bool ShouldTrace(TraceEventCache cache, string source, TraceEventType eventType, int id, string formatOrMessage, object[] args, object data1, object[] data) { return(Filter?.ShouldTrace(cache, source, eventType, id, formatOrMessage, args, data1, data) ?? true); }
internal void LogEvent(TraceEventType type, EventLogCategory category, EventLogEventId eventId, bool shouldTrace, params string[] values) { try { int length = 0; string[] strArrays = new string[(int)values.Length + 2]; for (int i = 0; i < (int)values.Length; i++) { string str = values[i]; str = (string.IsNullOrEmpty(str) ? string.Empty : EventLogger.NormalizeEventLogParameter(str)); strArrays[i] = str; length = length + str.Length + 1; } string str1 = EventLogger.NormalizeEventLogParameter(DiagnosticTrace.ProcessName); strArrays[(int)strArrays.Length - 2] = str1; length = length + str1.Length + 1; string str2 = DiagnosticTrace.ProcessId.ToString(CultureInfo.InvariantCulture); strArrays[(int)strArrays.Length - 1] = str2; length = length + str2.Length + 1; if (length > 25600) { int num = 25600 / (int)strArrays.Length - 1; for (int j = 0; j < (int)strArrays.Length; j++) { if (strArrays[j].Length > num) { strArrays[j] = strArrays[j].Substring(0, num); } } } using (SafeEventLogWriteHandle safeEventLogWriteHandle = SafeEventLogWriteHandle.RegisterEventSource(null, this.eventLogSourceName)) { if (safeEventLogWriteHandle != null) { SecurityIdentifier user = WindowsIdentity.GetCurrent().User; byte[] numArray = new byte[user.BinaryLength]; user.GetBinaryForm(numArray, 0); IntPtr[] intPtrArray = new IntPtr[(int)strArrays.Length]; GCHandle gCHandle = GCHandle.Alloc(intPtrArray, GCHandleType.Pinned); GCHandle[] gCHandleArray = null; try { gCHandleArray = new GCHandle[(int)strArrays.Length]; for (int k = 0; k < (int)strArrays.Length; k++) { gCHandleArray[k] = GCHandle.Alloc(strArrays[k], GCHandleType.Pinned); intPtrArray[k] = gCHandleArray[k].AddrOfPinnedObject(); } HandleRef handleRef = new HandleRef(safeEventLogWriteHandle, gCHandle.AddrOfPinnedObject()); Microsoft.ServiceBus.Diagnostics.NativeMethods.ReportEvent(safeEventLogWriteHandle, (ushort)EventLogger.EventLogEntryTypeFromEventType(type), (ushort)category, (uint)eventId, numArray, (ushort)((int)strArrays.Length), 0, handleRef, null); } finally { if (gCHandle.AddrOfPinnedObject() != IntPtr.Zero) { gCHandle.Free(); } if (gCHandleArray != null) { GCHandle[] gCHandleArray1 = gCHandleArray; for (int l = 0; l < (int)gCHandleArray1.Length; l++) { gCHandleArray1[l].Free(); } } } } } if (shouldTrace && this.diagnosticTrace != null) { Dictionary <string, string> strs = new Dictionary <string, string>((int)strArrays.Length + 4); strs["CategoryID.Name"] = category.ToString(); strs["CategoryID.Value"] = category.ToString(CultureInfo.InvariantCulture); strs["InstanceID.Name"] = eventId.ToString(); strs["InstanceID.Value"] = eventId.ToString(CultureInfo.InvariantCulture); for (int m = 0; m < (int)values.Length; m++) { strs.Add(string.Concat("Value", m.ToString(CultureInfo.InvariantCulture)), (values[m] == null ? string.Empty : DiagnosticTrace.XmlEncode(values[m]))); } this.diagnosticTrace.TraceEvent(type, TraceCode.EventLog, Microsoft.ServiceBus.SR.GetString(Resources.TraceCodeEventLog, new object[0]), new DictionaryTraceRecord(strs), null, null); } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } } }
public void TraceData(TraceEventType eventType, int id, params object[] data) { Trace.TraceData(eventType, id, data); }
public static void 设置(Action <M日志> __记录信息, TraceEventType __等级 = TraceEventType.Information) { _记录信息 = __记录信息; _等级 = __等级; }
public void TraceEvent(TraceEventType eventType, int id, string format, params object[] args) { Trace.TraceEvent(eventType, id, format, args); }
public void TraceData(TraceEventType eventType, int id, object data) { Trace.TraceData(eventType, id, data); }