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