public void TraceData(TraceEventType eventType, int id, LogEntry logEntry, TraceListenerFilter traceListenerFilter) { if (!ShouldTrace(eventType)) { return; } foreach (TraceListener listener in traceListenerFilter.GetAvailableTraceListeners(traceListeners)) { try { if (!listener.IsThreadSafe) { Monitor.Enter(listener); } listener.TraceData(manager, Name, eventType, id, logEntry); instrumentationProvider.FireTraceListenerEntryWrittenEvent(); listener.Flush(); } finally { if (!listener.IsThreadSafe) { Monitor.Exit(listener); } } } }
internal void TraceData( TraceEventType eventType, int id, LogEntry logEntry, TraceListenerFilter traceListenerFilter, TraceEventCache traceEventCache) { if (!ShouldTrace(eventType)) { return; } bool isTransfer = logEntry.Severity == TraceEventType.Transfer && logEntry.RelatedActivityId != null; foreach (TraceListener listener in traceListenerFilter.GetAvailableTraceListeners(traceListeners)) { try { if (!listener.IsThreadSafe) { Monitor.Enter(listener); } if (!isTransfer) { listener.TraceData(traceEventCache, Name, eventType, id, logEntry); } else { listener.TraceTransfer(traceEventCache, Name, id, logEntry.Message, logEntry.RelatedActivityId.Value); } instrumentationProvider.FireTraceListenerEntryWrittenEvent(); if (this.AutoFlush) { listener.Flush(); } } finally { if (!listener.IsThreadSafe) { Monitor.Exit(listener); } } } }
private void ProcessLog(LogEntry log) { ContextItems items = new ContextItems(); items.ProcessContextItems(log); IEnumerable <LogSource> matchingTraceSources = GetMatchingTraceSources(log); TraceListenerFilter traceListenerFilter = new TraceListenerFilter(); foreach (LogSource traceSource in matchingTraceSources) { try { traceSource.TraceData(log.Severity, log.EventId, log, traceListenerFilter); } catch (Exception ex) { ReportExceptionDuringTracing(ex, log, traceSource); } } }
void ProcessLog(LogEntry log) { // revert any outstanding impersonation using (WindowsImpersonationContext revertImpersonationContext = RevertExistingImpersonation()) { ContextItems items = new ContextItems(); items.ProcessContextItems(log); IEnumerable <LogSource> matchingTraceSources = GetMatchingTraceSources(log); TraceListenerFilter traceListenerFilter = new TraceListenerFilter(); foreach (LogSource traceSource in matchingTraceSources) { try { traceSource.TraceData(log.Severity, log.EventId, log, traceListenerFilter); } catch (Exception ex) { ReportExceptionDuringTracing(ex, log, traceSource); } } } }
private void ProcessLog(LogEntry log, TraceEventCache traceEventCache) { // revert any outstanding impersonation using (RevertExistingImpersonation()) { var items = new ContextItems(); items.ProcessContextItems(log); var matchingTraceSources = GetMatchingTraceSources(log); var traceListenerFilter = new TraceListenerFilter(); foreach (LogSource traceSource in matchingTraceSources) { try { traceSource.TraceData(log.Severity, log.EventId, log, traceListenerFilter, traceEventCache); } catch (Exception ex) { ReportExceptionDuringTracing(ex, log, traceSource); } } } }
public void TraceData(TraceEventType eventType, int id, LogEntry logEntry, TraceListenerFilter traceListenerFilter) { if (!ShouldTrace(eventType)) return; foreach (TraceListener listener in traceListenerFilter.GetAvailableTraceListeners(traceListeners)) { try { if (!listener.IsThreadSafe) Monitor.Enter(listener); listener.TraceData(manager, Name, eventType, id, logEntry); instrumentationProvider.FireTraceListenerEntryWrittenEvent(); listener.Flush(); } finally { if (!listener.IsThreadSafe) Monitor.Exit(listener); } } }
internal void TraceData( TraceEventType eventType, int id, LogEntry logEntry, TraceListenerFilter traceListenerFilter, TraceEventCache traceEventCache, ReportTracingError reportError) { if (!ShouldTrace(eventType)) { return; } bool isTransfer = logEntry.Severity == TraceEventType.Transfer && logEntry.RelatedActivityId != null; try { foreach (TraceListener listener in traceListenerFilter.GetAvailableTraceListeners(traceListeners)) { var asynchronousListener = listener as IAsynchronousTraceListener; if (asynchronousListener == null) { try { if (!listener.IsThreadSafe) { Monitor.Enter(listener); } if (!isTransfer) { listener.TraceData(traceEventCache, this.Name, eventType, id, logEntry); } else { listener.TraceTransfer(traceEventCache, this.Name, id, logEntry.Message, logEntry.RelatedActivityId.Value); } if (this.AutoFlush) { listener.Flush(); } } finally { if (!listener.IsThreadSafe) { Monitor.Exit(listener); } } } else { if (!isTransfer) { asynchronousListener.TraceData(traceEventCache, this.Name, eventType, id, logEntry, reportError); } else { asynchronousListener.TraceTransfer(traceEventCache, this.Name, id, logEntry.Message, logEntry.RelatedActivityId.Value, reportError); } if (this.AutoFlush) { asynchronousListener.Flush(reportError); } } } } catch (Exception e) { if (reportError == null) { throw; } reportError(e, logEntry, this.name); } }
/// <summary> /// Writes trace data to the trace listeners in the <see cref="LogSource.Listeners"/> collection that have not already been /// written to for tracing using the specified event type, event identifier, and trace data. /// </summary> /// <remarks> /// The <paramref name="traceListenerFilter"/> will be updated to reflect the trace listeners that were written to by the /// <see cref="LogSource"/>. /// </remarks> /// <param name="eventType">The value that specifies the type of event that caused the trace.</param> /// <param name="id">A numeric identifier for the event.</param> /// <param name="logEntry">The <see cref="LogEntry"/> to trace.</param> /// <param name="traceListenerFilter">The filter for already written to trace listeners.</param> public void TraceData(TraceEventType eventType, int id, LogEntry logEntry, TraceListenerFilter traceListenerFilter) { this.TraceData(eventType, id, logEntry, traceListenerFilter, new TraceEventCache(), null); }
internal void TraceData( TraceEventType eventType, int id, LogEntry logEntry, TraceListenerFilter traceListenerFilter, TraceEventCache traceEventCache) { if (!ShouldTrace(eventType)) return; bool isTransfer = logEntry.Severity == TraceEventType.Transfer && logEntry.RelatedActivityId != null; foreach (TraceListener listener in traceListenerFilter.GetAvailableTraceListeners(traceListeners)) { try { if (!listener.IsThreadSafe) Monitor.Enter(listener); if (!isTransfer) { listener.TraceData(traceEventCache, Name, eventType, id, logEntry); } else { listener.TraceTransfer(traceEventCache, Name, id, logEntry.Message, logEntry.RelatedActivityId.Value); } instrumentationProvider.FireTraceListenerEntryWrittenEvent(); if (this.AutoFlush) { listener.Flush(); } } finally { if (!listener.IsThreadSafe) Monitor.Exit(listener); } } }
/// <summary> /// Writes trace data to the trace listeners in the <see cref="LogSource.Listeners"/> collection that have not already been /// written to for tracing using the specified event type, event identifier, and trace data. /// </summary> /// <remarks> /// The <paramref name="traceListenerFilter"/> will be updated to reflect the trace listeners that were written to by the /// <see cref="LogSource"/>. /// </remarks> /// <param name="eventType">The value that specifies the type of event that caused the trace.</param> /// <param name="id">A numeric identifier for the event.</param> /// <param name="logEntry">The <see cref="LogEntry"/> to trace.</param> /// <param name="traceListenerFilter">The filter for already written to trace listeners.</param> public void TraceData(TraceEventType eventType, int id, LogEntry logEntry, TraceListenerFilter traceListenerFilter) { this.TraceData(eventType, id, logEntry, traceListenerFilter, new TraceEventCache()); }
internal void TraceData( TraceEventType eventType, int id, LogEntry logEntry, TraceListenerFilter traceListenerFilter, TraceEventCache traceEventCache, ReportTracingError reportError) { if (!ShouldTrace(eventType)) return; bool isTransfer = logEntry.Severity == TraceEventType.Transfer && logEntry.RelatedActivityId != null; try { foreach (TraceListener listener in traceListenerFilter.GetAvailableTraceListeners(traceListeners)) { var asynchronousListener = listener as IAsynchronousTraceListener; if (asynchronousListener == null) { try { if (!listener.IsThreadSafe) Monitor.Enter(listener); if (!isTransfer) { listener.TraceData(traceEventCache, this.Name, eventType, id, logEntry); } else { listener.TraceTransfer(traceEventCache, this.Name, id, logEntry.Message, logEntry.RelatedActivityId.Value); } if (this.AutoFlush) { listener.Flush(); } } finally { if (!listener.IsThreadSafe) Monitor.Exit(listener); } } else { if (!isTransfer) { asynchronousListener.TraceData(traceEventCache, this.Name, eventType, id, logEntry, reportError); } else { asynchronousListener.TraceTransfer(traceEventCache, this.Name, id, logEntry.Message, logEntry.RelatedActivityId.Value, reportError); } if (this.AutoFlush) { asynchronousListener.Flush(reportError); } } } } catch (Exception e) { if (reportError == null) { throw; } reportError(e, logEntry, this.name); } }