public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args) { lock (_sync) { if(Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, format, args, null, null)) return; ConsoleColor color; switch (eventType) { case TraceEventType.Error: color = ConsoleColor.Red; break; case TraceEventType.Warning: color = ConsoleColor.Yellow; break; case TraceEventType.Information: color = ConsoleColor.Green; break; case TraceEventType.Verbose: color = ConsoleColor.DarkCyan; break; default: color = ConsoleColor.Gray; break; } var eventTypeString = Enum.GetName(typeof (TraceEventType), eventType); var message = source + " - " + eventTypeString + " > " + (args.Length > 0 ? string.Format(format, args): format); WriteColor(message + Environment.NewLine, color); } }
/// <summary> /// Writes the specified trace level, message and optional exception. /// </summary> /// <param name="level">The <see cref="TraceLevel"/> at which to write this trace.</param> /// <param name="message">The trace message.</param> /// <param name="ex">The trace exception. This parameter is optional.</param> public void Trace(TraceLevel level, string message, Exception ex) { if (level == TraceLevel.Off) { return; } TraceEventCache eventCache = new TraceEventCache(); TraceEventType traceEventType = GetTraceEventType(level); foreach (TraceListener listener in DiagnosticsTrace.Listeners) { if (!listener.IsThreadSafe) { lock (listener) { listener.TraceEvent(eventCache, "Newtonsoft.Json", traceEventType, 0, message); } } else { listener.TraceEvent(eventCache, "Newtonsoft.Json", traceEventType, 0, message); } if (DiagnosticsTrace.AutoFlush) { listener.Flush(); } } }
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()); } } }
/// <summary> /// Forwards the trace request to the wrapped listener. /// </summary> /// <param name="eventCache">The context information.</param> /// <param name="source">The trace source.</param> /// <param name="severity">The severity.</param> /// <param name="id">The event id.</param> /// <param name="data">The objects to trace.</param> public override void TraceData(TraceEventCache eventCache, string source, TraceEventType severity, int id, params object[] data) { if ((this.Filter == null) || this.Filter.ShouldTrace(eventCache, source, severity, id, null, null, null, data)) { this.innerListener.TraceData(eventCache, source, severity, id, data); } }
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data) { LogMessage msg = (LogMessage)data; byte[] buf = FormatMessage(string.Concat(msg.MessageAsText, "\n")); Stream.Write(buf, 0, buf.Length); // Write message buffer Stream.Flush(); }
public override void TraceEvent (TraceEventCache eventCache, string source, TraceEventType severity, int id, string message) { if (HttpContext.Current == null || HttpContext.Current.Trace == null) return; HttpContext.Current.Trace.Write (source, message); }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args) { if (args == null || args.Length == 0) Append(eventType, format); else Append(eventType, String.Format(format, args)); }
public override 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)) { var prefix = source; var dotIndex = prefix.LastIndexOf('.'); if (dotIndex != -1) prefix = prefix.Substring(dotIndex + 1); switch (eventType) { case TraceEventType.Critical: case TraceEventType.Error: Trace.TraceError("[{0}] {1}", prefix, message); break; case TraceEventType.Verbose: case TraceEventType.Information: Trace.TraceInformation("[{0}] {1}", prefix, message); break; case TraceEventType.Warning: Trace.TraceWarning("[{0}] {1}", prefix, message); break; default: break; } } }
void PrintThreadId(TraceEventCache info) { Console.Out.Write("["); Console.Out.Write(info.ThreadId); Console.Out.Write("]"); Console.Out.Write(" "); }
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 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); } }
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); } }
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 void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data) { tracedData = data; tracedSource = source; tracedEventType = eventType; entries.Add(data as LogEntry); }
/// <summary> /// Writes the specified trace level, message and optional exception. /// </summary> /// <param name="level">The <see cref="TraceLevel"/> at which to write this trace.</param> /// <param name="message">The trace message.</param> /// <param name="ex">The trace exception. This parameter is optional.</param> public void Trace(TraceLevel level, string message, Exception ex) { if (level == TraceLevel.Off) return; TraceEventCache eventCache = new TraceEventCache(); TraceEventType traceEventType = GetTraceEventType(level); foreach (TraceListener listener in DiagnosticsTrace.Listeners) { if (!listener.IsThreadSafe) { lock (listener) { listener.TraceEvent(eventCache, "Framework.Qlh.Common.Infrastructure.Json", traceEventType, 0, message); } } else { listener.TraceEvent(eventCache, "Framework.Qlh.Common.Infrastructure.Json", traceEventType, 0, message); } if (DiagnosticsTrace.AutoFlush) listener.Flush(); } }
public void Write(LogEntry entry, Type filterListener) { Guard.ArgumentNotNull(entry, "entry"); TraceEventCache manager = new TraceEventCache(); foreach(TraceListener listener in this.Listeners) { bool lockTaken = false; try { if (!listener.IsThreadSafe) { Monitor.Enter(sync, ref lockTaken); } if (filterListener == null || filterListener == listener.GetType()) { listener.TraceData(manager, string.Empty, entry.Severity, 0, entry); listener.Flush(); } } finally { if (!listener.IsThreadSafe && lockTaken) { Monitor.Exit(sync); } } } }
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); } }
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); } }
public override void TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId) { lock(traceRequestMonitor) { MockTraceListener.transferGuids.Add(relatedActivityId); } }
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); }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args) { ConsoleColor originalColor = Console.ForegroundColor; Console.ForegroundColor = GetEventColor(eventType, originalColor); base.WriteLine(string.Format(format, args)); Console.ForegroundColor = originalColor; }
/// <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; }
protected override void TraceSimpleEvent(DateTime eventTime, Int32 threadId, TraceEventType eventType, String message, Int32 eventId, TraceEventCache eventCache, String source) { if (_table != null) { if (message.StartsWith("#Status ") || message.StartsWith("#Status:")) { Status status = new Status(eventTime.ToUniversalTime()); status.Level = eventType.ToString(); status.ThreadId = threadId; string messageText; string dataText; GetMessageParts(message, out messageText, out dataText); status.Message = messageText; status.Data = dataText; try { TableOperation operation = TableOperation.Insert(status); this._table.Execute(operation); } catch (Exception e) { Console.WriteLine("Exception while saving to Azure storage."); Console.WriteLine(e.ToString()); throw; } } } }
/// <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 TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId) { //this.WriteHeader(source, TraceEventType.Transfer, id, eventCache, relatedActivityId); //this.WriteEscaped(message); //this.WriteFooter(eventCache); }
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 void WriteEvent(string message, string source, TraceEventType type) { var ctx = BeforeWriteEvent(); try { if (source == null) { source = s_processFileName; } var evtId = Interlocked.Increment(ref _evtId); var evtCache = new TraceEventCache(); foreach (TraceListener l in listeners) { lock (l) { try { l.TraceEvent(evtCache, source, type, evtId, message); if (Trace.AutoFlush) { l.Flush(); } } catch { //swallow error Debugger.Break(); } } } } finally { AfterWriteEvent(ctx); } }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id) { if (_enabled) { WebSocketHost.Send($"{eventType}:{id} - {source}"); } }
/// <summary> /// Traces the message. Supported event types are: Critical, Error, Information and Warning. /// </summary> public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message) { if (Logger != null) { switch (eventType) { case TraceEventType.Critical: { Logger.Fatal(message); } break; case TraceEventType.Error: { Logger.Error(message); } break; case TraceEventType.Information: { Logger.Info(message); } break; case TraceEventType.Warning: { Logger.Warn(message); } break; } } }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args) { string message = string.Format(format, args); // write the localised date and time but include the time zone in brackets (good for combining logs from different timezones) TimeSpan utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now); string plusOrMinus = (utcOffset < TimeSpan.Zero) ? "-" : "+"; string utcHourOffset = utcOffset.TotalHours == 0 ? string.Empty : string.Format(" ({0}{1:hh})", plusOrMinus, utcOffset); string dateWithOffset = string.Format(@"{0:yyyy/MM/dd HH:mm:ss.fff}{1}", DateTime.Now, utcHourOffset); // display the threadid string log = string.Format(@"{0} [{1}] {2}", dateWithOffset, Thread.CurrentThread.ManagedThreadId, message); switch (eventType) { case TraceEventType.Critical: case TraceEventType.Error: Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(log); Console.ResetColor(); break; case TraceEventType.Warning: Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine(log); Console.ResetColor(); break; default: Console.WriteLine(log); break; } }
/// <summary> /// Method invoked when data needs to be traced. Will filter based on current trace options /// </summary> /// <param name="eventCache">TraceEventCache</param> /// <param name="source">Source</param> /// <param name="eventType">TraceEventType</param> /// <param name="id">ID</param> /// <param name="data">Data</param> public override void TraceData(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, object data) { // If there's no filter means we should log everything if (this.Filter == null || this.Filter.ShouldTrace(eventCache, source, eventType, id, null, null, data, null)) { this.AddNewEntry(data as LogEntry); } }
/// <summary> /// Writes trace information, a message, 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="message">A message to write.</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(System.Diagnostics.TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message) { // Check if any filters exist if (SourceFilters != null) { if (SourceFilters.Count > 0) { bool isFilterMatched = false; // If there are filters, check to make sure the source matches one of the filters. If it doesn't, then just return. foreach (string filter in SourceFilters) { if (String.Compare(source, filter, true) == 0) { isFilterMatched = true; break; } } if (!isFilterMatched) { return; } } } if (MessageKeywordFilters != null) { if (MessageKeywordFilters.Count > 0) { bool isFilterMatched = false; foreach (string keyword in MessageKeywordFilters) { if (message.Contains(keyword)) { isFilterMatched = true; break; } } if (!isFilterMatched) { return; } } } string timestamp = eventCache.DateTime.ToLocalTime().ToString("[MM/dd/yy HH:mm:ss.ffff] "); // Prepend timestamp to messages with multiple lines so that addition lines in message // lines up to first line after the timestamp if (message.Contains(Environment.NewLine)) { message = message.Replace(Environment.NewLine, Environment.NewLine + timestamp); } Write(timestamp + message); }
private void PurgeLogFiles(int maxFilesToKeep, System.Diagnostics.TraceEventCache eventCache) { string fileFilter = BaseFileName + "*.log"; lock (_purgeLock) { if (DateTime.Now.Date == _lastPurgeDateTime.Date) { // only need to perform one purge per day (since this is a daily logger). return; } else if (Directory.GetFiles(CustomLocation, fileFilter).Length <= maxFilesToKeep) { // purge only if more than max number of log files allowed return; } else if (_purgeTask != null && _purgeTask.Status == TaskStatus.Running) { // purge only if no purge task is in progress return; } else { _lastPurgeDateTime = DateTime.Now; // record purge date/time _purgeTask = Task.Factory.StartNew(() => { var logDir = CustomLocation; var logFileList = new DirectoryInfo(logDir).GetFiles(fileFilter); var sorted = logFileList.OrderBy(f => f.LastWriteTime).ToList(); while (sorted.Count > maxFilesToKeep) { File.Delete(sorted[0].FullName); sorted.RemoveAt(0); } }); // handle exception if any _purgeTask.ContinueWith(t => { Exception ex = t.Exception; if (ex != null && ex.InnerException != null) { ex = ex.InnerException; // Only want to log purge error once during the life of the run app. // Otherwise, we could potentially log purge error for each log message! if (!_purgeErrLogged) { _purgeErrLogged = true; string message = "DailyTextWriterListener.PurgeLogFiles(): failed with exception: " + ex.ToString(); base.WriteLine(eventCache.DateTime.ToLocalTime().ToString("MM/dd/yy,HH:mm:ss.ffff,") + message); } } }); } // else } // lock }
public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, int id) { TraceEvent(eventCache, source, eventType, id, String.Empty); }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message) { throw new NotImplementedException(); }
public override void TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId) { throw new NotImplementedException(); }
public override void TraceEvent(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType severity, int id, string message) { }
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args) { throw new NotImplementedException(); }
private void WriteHeader(String source, TraceEventType eventType, int id, TraceEventCache eventCache) { WriteStartHeader(source, eventType, id, eventCache); WriteEndHeader(eventCache); }
public virtual void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message) { TraceData(eventCache, source, eventType, id, message); }
public virtual void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object [] args) { TraceEvent(eventCache, source, eventType, id, String.Format(format, args)); }
public virtual void TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId) { TraceEvent(eventCache, source, TraceEventType.Transfer, id, String.Format("{0}, relatedActivityId={1}", message, relatedActivityId)); }
void TraceCore(TraceEventCache eventCache, string source, TraceEventType eventType, int id, bool hasRelatedActivity, Guid relatedActivity, int level, bool wrapData, params object [] data) { Process p = eventCache != null? Process.GetProcessById(eventCache.ProcessId) : Process.GetCurrentProcess(); w.WriteStartElement("E2ETraceEvent", e2e_ns); // <System> w.WriteStartElement("System", sys_ns); w.WriteStartElement("EventID", sys_ns); w.WriteString(XmlConvert.ToString(id)); w.WriteEndElement(); // FIXME: find out what should be written w.WriteStartElement("Type", sys_ns); w.WriteString("3"); w.WriteEndElement(); w.WriteStartElement("SubType", sys_ns); // FIXME: it does not seem always to match eventType value ... w.WriteAttributeString("Name", eventType.ToString()); // FIXME: find out what should be written w.WriteString("0"); w.WriteEndElement(); // FIXME: find out what should be written w.WriteStartElement("Level", sys_ns); w.WriteString(level.ToString()); w.WriteEndElement(); w.WriteStartElement("TimeCreated", sys_ns); w.WriteAttributeString("SystemTime", XmlConvert.ToString(eventCache != null ? eventCache.DateTime : DateTime.Now)); w.WriteEndElement(); w.WriteStartElement("Source", sys_ns); w.WriteAttributeString("Name", source); w.WriteEndElement(); w.WriteStartElement("Correlation", sys_ns); w.WriteAttributeString("ActivityID", String.Concat("{", Guid.Empty, "}")); w.WriteEndElement(); w.WriteStartElement("Execution", sys_ns); // FIXME: which should I use here? //w.WriteAttributeString ("ProcessName", p.ProcessName); w.WriteAttributeString("ProcessName", p.MainModule.ModuleName); w.WriteAttributeString("ProcessID", p.Id.ToString()); w.WriteAttributeString("ThreadID", eventCache != null ? eventCache.ThreadId : Thread.CurrentThread.ManagedThreadId.ToString()); w.WriteEndElement(); w.WriteStartElement("Channel", sys_ns); // FIXME: find out what should be written. w.WriteEndElement(); w.WriteStartElement("Computer"); w.WriteString(p.MachineName); w.WriteEndElement(); w.WriteEndElement(); // <ApplicationData> w.WriteStartElement("ApplicationData", e2e_ns); w.WriteStartElement("TraceData", e2e_ns); foreach (object o in data) { if (wrapData) { w.WriteStartElement("DataItem", e2e_ns); } if (o is XPathNavigator) { // the output ignores xmlns difference between the parent (E2ETraceEvent and the content node). // To clone such behavior, I took this approach. w.WriteRaw(XPathNavigatorToString((XPathNavigator)o)); } else if (o != null) { w.WriteString(o.ToString()); } if (wrapData) { w.WriteEndElement(); } } w.WriteEndElement(); w.WriteEndElement(); w.WriteEndElement(); w.Flush(); // for XmlWriter Flush(); // for TextWriter }
void TraceCore(TraceEventCache eventCache, string source, TraceEventType eventType, int id, bool hasRelatedActivity, Guid relatedActivity, int level, bool wrapData, params object [] data) { Process p = eventCache != null? Process.GetProcessById(eventCache.ProcessId) : Process.GetCurrentProcess(); w.WriteStartElement("E2ETraceEvent", e2e_ns); // <System> w.WriteStartElement("System", sys_ns); w.WriteStartElement("EventID", sys_ns); w.WriteString(XmlConvert.ToString(id)); w.WriteEndElement(); // FIXME: find out what should be written w.WriteStartElement("Type", sys_ns); w.WriteString("3"); w.WriteEndElement(); w.WriteStartElement("SubType", sys_ns); // FIXME: it does not seem always to match eventType value ... w.WriteAttributeString("Name", eventType.ToString()); // FIXME: find out what should be written w.WriteString("0"); w.WriteEndElement(); // FIXME: find out what should be written w.WriteStartElement("Level", sys_ns); w.WriteString(level.ToString()); w.WriteEndElement(); w.WriteStartElement("TimeCreated", sys_ns); w.WriteAttributeString("SystemTime", XmlConvert.ToString(eventCache != null ? eventCache.DateTime : DateTime.Now)); w.WriteEndElement(); w.WriteStartElement("Source", sys_ns); w.WriteAttributeString("Name", source); w.WriteEndElement(); w.WriteStartElement("Correlation", sys_ns); w.WriteAttributeString("ActivityID", String.Concat("{", Guid.Empty, "}")); w.WriteEndElement(); w.WriteStartElement("Execution", sys_ns); // FIXME: which should I use here? //w.WriteAttributeString ("ProcessName", p.ProcessName); w.WriteAttributeString("ProcessName", p.MainModule.ModuleName); w.WriteAttributeString("ProcessID", p.Id.ToString()); w.WriteAttributeString("ThreadID", eventCache != null ? eventCache.ThreadId : Thread.CurrentThread.ManagedThreadId.ToString()); w.WriteEndElement(); w.WriteStartElement("Channel", sys_ns); // FIXME: find out what should be written. w.WriteEndElement(); w.WriteStartElement("Computer"); w.WriteString(p.MachineName); w.WriteEndElement(); w.WriteEndElement(); // <ApplicationData> w.WriteStartElement("ApplicationData", e2e_ns); foreach (object o in data) { if (wrapData) { w.WriteStartElement("TraceData", e2e_ns); } if (o != null) { w.WriteString(o.ToString()); } if (wrapData) { w.WriteEndElement(); } } w.WriteEndElement(); w.WriteEndElement(); }
public override void TraceData(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, object data) { }
public override bool ShouldTrace(TraceEventCache cache, string source, TraceEventType eventType, int id, string formatOrMessage, Object[] args, Object data1, Object[] data) { return(default(bool)); }
private void WriteStartHeader(String source, TraceEventType eventType, int id, TraceEventCache eventCache) { InternalWrite(fixedHeader); InternalWrite("<EventID>"); InternalWrite(((uint)id).ToString(CultureInfo.InvariantCulture)); InternalWrite("</EventID>"); InternalWrite("<Type>3</Type>"); InternalWrite("<SubType Name=\""); InternalWrite(eventType.ToString()); InternalWrite("\">0</SubType>"); InternalWrite("<Level>"); int sev = (int)eventType; if (sev > 255) { sev = 255; } if (sev < 0) { sev = 0; } InternalWrite(sev.ToString(CultureInfo.InvariantCulture)); InternalWrite("</Level>"); InternalWrite("<TimeCreated SystemTime=\""); if (eventCache != null) { InternalWrite(eventCache.DateTime.ToString("o", CultureInfo.InvariantCulture)); } else { InternalWrite(DateTime.Now.ToString("o", CultureInfo.InvariantCulture)); } InternalWrite("\" />"); InternalWrite("<Source Name=\""); WriteEscaped(source); InternalWrite("\" />"); InternalWrite("<Correlation ActivityID=\""); if (eventCache != null) { InternalWrite(eventCache.ActivityId.ToString("B")); } else { InternalWrite(Guid.Empty.ToString("B")); } }
public virtual void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id) { TraceEvent(eventCache, source, eventType, id, null); }
/// <summary> /// Writes trace information, a message and event information to the output file or stream. /// </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 of the trace source that invoked this method.</param> /// <param name="eventType">One of the <see cref="T:System.Diagnostics.TraceEventType" /> enumeration values.</param> /// <param name="id">A numeric identifier for the event.</param> /// <param name="message">A message to write.</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.FileIOPermission, 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(System.Diagnostics.TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message) { if (!eventType.Equals(TraceEventType.Critical)) { char eventTypeChar = 'E'; switch (eventType) { case TraceEventType.Information: eventTypeChar = 'I'; break; case TraceEventType.Warning: eventTypeChar = 'W'; break; case TraceEventType.Error: eventTypeChar = 'E'; break; case TraceEventType.Critical: eventTypeChar = 'C'; break; } string header = String.Format("{0},{1},{2},", eventCache.DateTime.ToLocalTime().ToString("MM/dd/yy,HH:mm:ss.ffff"), id, eventTypeChar); // Prepend timestamp to messages with multiple lines so that addition lines in message // lines up to first line after the timestamp if (message.Contains(Environment.NewLine)) { message = message.Replace(Environment.NewLine, Environment.NewLine + header); } BaseFileName = OriginalFileName + "_H" + DateTime.Now.Hour; base.WriteLine(header + message); PurgeLogFiles(MaxLogFilesAllowed, eventCache); // purge older log files if got to many } else { // Maintenance log file header.. string _date = DateTime.Now.ToString("-yyyy-MM-dd"); string LogFilePathForMaintenance = string.Format("{0}\\{1}_Maintenance{2}.log", CustomLocation, OriginalFileName, _date); if (!File.Exists(LogFilePathForMaintenance)) { // File.Create(LogFilePathForMaintenance).Dispose(); using (StreamWriter w = File.AppendText(LogFilePathForMaintenance)) { w.WriteLine("Time Stamp, Error Code, Error Category, Error Message, Type"); w.Close(); } } BaseFileName = OriginalFileName + "_Maintenance"; string header = String.Format("{0},", eventCache.DateTime.ToLocalTime().ToString("MM/dd/yy - HH:mm:ss")); // Prepend timestamp to messages with multiple lines so that addition lines in message // lines up to first line after the timestamp if (message.Contains(Environment.NewLine)) { message = message.Replace(Environment.NewLine, Environment.NewLine + header); } //Force to be not over 5 comma index var msgsplit = message.Split(','); if (msgsplit.Length > 4) { message = string.Empty; message = string.Format("{0},{1},{2},{3}", msgsplit[0], msgsplit[1], msgsplit[2], msgsplit[3]); } base.WriteLine(header + message); } }
public override bool ShouldTrace(TraceEventCache cache, string source, TraceEventType eventType, int id, string formatOrMessage, object[] args, object data1, object[] data) { return(((int)eventType & (int)level) != 0); }
public override bool ShouldTrace(System.Diagnostics.TraceEventCache cache, string source, System.Diagnostics.TraceEventType eventType, int id, string formatOrMessage, object[] args, object data1, object[] data) { throw null; }
public virtual void TraceEvent(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, string format, params object[] args) { }
public override void TraceData(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType severity, int id, params object[] data) { }
public virtual void TraceEvent(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, string message) { }
public override void TraceEvent(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType severity, int id, string format, params object[] args) { }
public virtual void TraceData(System.Diagnostics.TraceEventCache eventCache, string source, System.Diagnostics.TraceEventType eventType, int id, params object[] data) { }
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data) { throw new NotImplementedException(); }
public abstract bool ShouldTrace(System.Diagnostics.TraceEventCache cache, string source, System.Diagnostics.TraceEventType eventType, int id, string formatOrMessage, object[] args, object data1, object[] data);
public virtual void TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId) { TraceEvent(eventCache, source, TraceEventType.Transfer, id, message + ", relatedActivityId=" + relatedActivityId.ToString()); }
public static void TraceEvent(TraceEventType eventType, int id, string?format, params object?[]?args) { TraceEventCache EventCache = new TraceEventCache(); if (UseGlobalLock) { lock (critSec) { if (args == null) { foreach (TraceListener listener in Listeners) { listener.TraceEvent(EventCache, AppName, eventType, id, format); if (AutoFlush) { listener.Flush(); } } } else { foreach (TraceListener listener in Listeners) { listener.TraceEvent(EventCache, AppName, eventType, id, format !, args); if (AutoFlush) { listener.Flush(); } } } } } else { if (args == null) { foreach (TraceListener listener in Listeners) { if (!listener.IsThreadSafe) { lock (listener) { listener.TraceEvent(EventCache, AppName, eventType, id, format); if (AutoFlush) { listener.Flush(); } } } else { listener.TraceEvent(EventCache, AppName, eventType, id, format); if (AutoFlush) { listener.Flush(); } } } } else { foreach (TraceListener listener in Listeners) { if (!listener.IsThreadSafe) { lock (listener) { listener.TraceEvent(EventCache, AppName, eventType, id, format !, args); if (AutoFlush) { listener.Flush(); } } } else { listener.TraceEvent(EventCache, AppName, eventType, id, format !, args); if (AutoFlush) { listener.Flush(); } } } } } }