public static void ImportFileErrorHandler(
[ErrorTrigger] TraceEvent error, string message, TextWriter log)
{
// Here you could send an error notification
log.WriteLine(string.Format("{0} : {1}", message, error.ToString()));
}
/// <summary>
/// Print data. Note that this method is called FROM DIFFERNET THREADS which means you need to properly
/// lock any read-write data you access. It turns out Out.Writeline is already thread safe so
/// there is nothing I have to do in this case.
/// </summary>
static void Print(TraceEvent data, SymbolReader symbolReader)
{
// There are a lot of data collection start on entry that I don't want to see (but often they are quite handy
if (data.Opcode == TraceEventOpcode.DataCollectionStart)
{
return;
}
// V3.5 runtimes don't log the stack and in fact don't event log the exception name (it shows up as an empty string)
// Just ignore these as they are not that interesting.
if (data is ExceptionTraceData && ((ExceptionTraceData)data).ExceptionType.Length == 0)
{
return;
}
Out.WriteLine("EVENT: {0}", data.ToString());
var callStack = data.CallStack();
if (callStack != null)
{
// Because symbol lookup is complex, error prone, and expensive TraceLog requires you to be explicit.
// Here we look up names in this call stack using the symbol reader.
ResolveNativeCode(callStack, symbolReader);
Out.WriteLine("CALLSTACK: {0}", callStack.ToString());
}
}
private void IAddEvent(TraceEvent te)
{
var p = new Paragraph
{
TextAlignment = TextAlignment.Left,
Margin = new Thickness(0),
Inlines =
{
//new Line() { X1 = 0, X2 = 40, Y1 = -4, Y2 = -4, StrokeThickness = 2, Stroke = TurnBrush },
new Run(te.ToString())
{
Foreground = _turnBrush, FontWeight = FontWeights.Bold
}
//new Line() { X1 = 0, X2 = 40, Y1 = -4, Y2 = -4, StrokeThickness = 2, Stroke = TurnBrush }
}
};
if (output.Document.Blocks.LastBlock != null)
{
if (((Paragraph)output.Document.Blocks.LastBlock).Inlines.Count == 0)
{
output.Document.Blocks.Remove(output.Document.Blocks.LastBlock);
}
}
output.Document.Blocks.Add(p);
output.Document.Blocks.Add(new Paragraph {
Margin = new Thickness()
}); // Restore left alignment
output.ScrollToEnd();
}
/// <summary>
/// Print data. Note that this method is called FROM DIFFERENT THREADS which means you need to properly
/// lock any read-write data you access. It turns out Out.WriteLine is already thread safe so
/// there is nothing I have to do in this case.
/// </summary>
static void Print(TraceEvent data)
{
// There are a lot of data collection start on entry that I don't want to see (but often they are quite handy
if (data.Opcode == TraceEventOpcode.DataCollectionStart)
{
return;
}
Out.WriteLine(data.ToString());
if (data is UnhandledTraceEvent)
{
Out.WriteLine(data.Dump());
}
}
/// <summary>
/// Print data. Note that this method is called FROM DIFFERNET THREADS which means you need to properly
/// lock any read-write data you access. It turns out Out.Writeline is already thread safe so
/// there is nothing I have to do in this case.
/// </summary>
private static void Print(TraceEvent data)
{
if (s_stopping) // Ctrl-C will stop the sessions, but buffered events may still come in, ignore these.
{
return;
}
// There are a lot of data collection start on entry that I don't want to see (but often they are quite handy
if (data.Opcode == TraceEventOpcode.DataCollectionStart)
{
return;
}
Out.WriteLine(data.ToString());
if (data is UnhandledTraceEvent)
{
Out.WriteLine(data.Dump());
}
}
private void InternalSendTraceTelemetry(TraceEvent eventData)
{
if (this.telemetryClient.TelemetryConfiguration.TelemetryChannel == null)
{
return;
}
var traceTelemetry = new TraceTelemetry
{
Message = eventData.ToString(),
};
if (!string.IsNullOrEmpty(this.DiagnosticsInstrumentationKey))
{
traceTelemetry.Context.InstrumentationKey = this.DiagnosticsInstrumentationKey;
}
traceTelemetry.Context.Operation.SyntheticSource = SdkTelemetrySyntheticSourceName;
this.telemetryClient.TrackTrace(traceTelemetry);
}
/// <summary>
/// Print data. Note that this method is called FROM DIFFERNET THREADS which means you need to properly
/// lock any read-write data you access. It turns out Out.Writeline is already thread safe so
/// there is nothing I have to do in this case.
/// </summary>
private static void Print(TraceEvent data)
{
// There are a lot of data collection start on entry that I don't want to see (but often they are quite handy
if (data.Opcode == TraceEventOpcode.DataCollectionStart || data.Opcode == TraceEventOpcode.DataCollectionStop)
{
return;
}
// Merging inject some 'symbol' events that are not that interesting so we ignore those too.
if (data.ProviderGuid == SymbolTraceEventParser.ProviderGuid)
{
return;
}
// To avoid 'rundown' events that happen in the beginning and end of the trace filter out things during those times
if (data.TimeStampRelativeMSec < 1000 || 9000 < data.TimeStampRelativeMSec)
{
return;
}
Out.WriteLine(data.ToString());
}
private void ProcessEvent(TraceEvent evt)
{
try
{
if (evt.ID == TraceEventUtil.ManifestEventID)
{
XElement element = XElement.Parse(evt.ToString());
byte[] eventData = Encoding.UTF8.GetBytes(element.FirstNode.ToString());
ProviderManifest manifest = new ProviderManifest(new MemoryStream(eventData), eventData.Length);
this.OnManifestReceived(manifest);
}
else
{
this.sink.OnNext(this.CreateEventEntry(evt));
}
}
catch (Exception exception)
{
this.logger.TraceEventServiceSinkUnhandledFault(this.sessionName, exception.ToString());
}
}
static void Print(TraceEvent data)
{
if (data.ProviderName.StartsWith("Microsoft.Streaming"))
{
var line = Encoding.UTF8.GetBytes(data.TimeStamp.ToString("hh.mm.ss.ffffff") + " " + data.ToString() + "\n");
fs.Write(line, 0, line.Length);
}
}
public void WriteMessage(TraceEvent traceEvent, string message)
{
WriteMessage(string.Concat(traceEvent.ToString().ToUpperInvariant(), ": ", message));
}