public string Format(TraceEvent traceEvent)
{
//string ret = format;
return format.
Replace("{%ContextHolderId}", traceEvent.ContextIdentifier.ContextHolderId.ToString()).
Replace("{%ExternalId}", traceEvent.ContextIdentifier.ExternalId.ToString()).
Replace("{%ExternalReference}", traceEvent.ContextIdentifier.ExternalReference.ToString()).
Replace("{%ExternalParentId}", traceEvent.ContextIdentifier.ExternalParentId.ToString()).
Replace("{%InternalId}", traceEvent.ContextIdentifier.InternalId.ToString()).
Replace("{%InternalParentId}", traceEvent.ContextIdentifier.InternalParentId.ToString()).
Replace("{%ContextGuid}", traceEvent.ContextIdentifier.ContextGuid.ToString()).
Replace("{%HostName}", traceEvent.Location.HostName).
Replace("{%ModulePath}", traceEvent.Location.ModulePath).
Replace("{%Principal}", traceEvent.Principal.Name).
Replace("{%ThreadName}", traceEvent.Location.ThreadName).
Replace("{%Message}", traceEvent.Message).
Replace("{%Source}", traceEvent.Location.Source).
Replace("{%Type}", traceEvent.Type.ToString()).
Replace("{%Category}", traceEvent.Category.ToString()).
Replace("{%EventIdText}", traceEvent.EventIdText).
Replace("{%Time}", traceEvent.Time.ToString("dd-MMM-yyyyTHH:mm:ss (fff)")).
Replace("{%EventId}", traceEvent.EventId.ToString()
);
// TODO: Provide specific format handling for the DateTime (SD)
}
public override void BeginIteration(TraceEvent beginEvent)
{
_objects = new ListMetricInfo();
_objects.clear();
_objects.hasCount = true;
_objects.hasBytes = true;
}
protected override void InvokeTextWriter(TraceEvent traceEvent)
{
if (MapTraceLevel(traceEvent.Source, traceEvent.Level) <= _traceConfig.ConsoleLevel)
{
// For Errors/Warnings we change the Console color
// for visibility
var holdColor = Console.ForegroundColor;
bool changedColor = false;
switch (traceEvent.Level)
{
case TraceLevel.Error:
Console.ForegroundColor = ConsoleColor.Red;
changedColor = true;
break;
case TraceLevel.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
changedColor = true;
break;
}
base.InvokeTextWriter(traceEvent);
if (changedColor)
{
Console.ForegroundColor = holdColor;
}
}
}
public InstanceConfiguration(DataSetConfiguration dataSet, ObservableCollection<MessageHandlerConfiguration> availableHandlers, TraceEvent trace, Action onModification)
{
AvailableMessageHandlers = availableHandlers;
AssociatedMessageHandlers = new ObservableCollection<MessageHandlerConfiguration>(availableHandlers.Where<MessageHandlerConfiguration>(x => x.Associated(dataSet.AssociationName)).ToArray<MessageHandlerConfiguration>());
DataSetConfiguration = dataSet;
PropertyChanged += (x, y) => onModification();
}
public void Send(TraceEvent eventData)
{
lock (this.eventList)
{
this.EventList.Add(eventData);
}
}
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 String GetKey(TraceEvent traceEvent)
{
// Original code combined the Provider GUID with the machine name
// but you cannot mix events with different partition keys in the same
// batch.
return Environment.MachineName;
}
private void EventReceived(TraceEvent traceEvent)
{
DisplayTraceEvent dte = new DisplayTraceEvent
{
TraceEvent = traceEvent,
};
foreach (IDisplayTraceEvents idt in _viewers)
{
if (idt.IsApplicable(traceEvent))
{
dte.DisplayTemplates.Add(idt.GetDisplayTemplate());
DataTemplate listTemplate = idt.GetListItemTemplate();
if (listTemplate != null)
{
dte.ListTemplate = listTemplate;
}
}
}
DisplayTraceEvents.Add(dte);
SelectedTab = 0;
}
public override void Trace(TraceEvent traceEvent)
{
// TODO: figure out the right log file format
// TODO: buffer logs and write only periodically
AppendLine(traceEvent.Message);
if (traceEvent.Exception != null)
{
if (traceEvent.Exception is FunctionInvocationException ||
traceEvent.Exception is AggregateException)
{
// we want to minimize the stack traces for function invocation
// failures, so we drill into the very inner exception, which will
// be the script error
Exception actualException = traceEvent.Exception;
while (actualException.InnerException != null)
{
actualException = actualException.InnerException;
}
AppendLine(actualException.Message);
}
else
{
AppendLine(traceEvent.Exception.ToString());
}
}
}
/// <inheritdoc/>
public override void Trace(TraceEvent traceEvent)
{
if (traceEvent == null)
{
throw new ArgumentNullException("traceEvent");
}
if (ShouldIgnore(traceEvent))
{
return;
}
try
{
foreach (TraceFilter filter in Filters)
{
// trace must be passed to all filters (even if no notifications will be
// performed due to throttling) to allow them to continue to accumulate their results
if (filter.Filter(traceEvent))
{
// Notify all subscribers
Notify(filter);
}
}
}
catch
{
// Need to prevent infinite loops when calling out to user code
// I.e., user code exception in error handler causes error filter/subscriber
// to be called again.
}
}
public unsafe ProcessAction(TraceEvent traceEvent)
{
EventName = traceEvent.EventName;
OpcodeName = traceEvent.OpcodeName;
PayloadNames = traceEvent.PayloadNames;
//
AffectedKeys = new AffectedKeys(traceEvent);
}
public override void Write(string message)
{
var te = new TraceEvent
{Cache = new TraceEventCache(), Message = message, Type = TraceEventType.Information};
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)
{
var te = new TraceEvent
{Cache = eventCache, Source = source, Type = eventType, Id = id, Format = format, Args = args};
Events.Add(te);
if (OnEventAdd != null)
OnEventAdd.Invoke(te);
}
public override void Write(string message)
{
TraceEvent te = new TraceEvent();
te.Cache = new TraceEventCache();
te.Message = message;
te.Type = TraceEventType.Information;
Events.Add(te);
if(OnEventAdd != null)
OnEventAdd.Invoke(te);
}
public override void Trace(TraceEvent traceEvent)
{
if (Level < traceEvent.Level)
{
return;
}
_interceptor(traceEvent);
InnerWriter.Trace(traceEvent);
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
{
TraceEvent te = new TraceEvent();
te.Cache = eventCache;
te.Source = source;
te.Type = eventType;
te.ID = id;
Events.Add(te);
if(OnEventAdd != null)
OnEventAdd.Invoke(te);
}
public void Trace(TraceEvent traceEvent)
{
foreach (var source in this.sources)
{
var diagnostics = source as IDiagnosticsTraceSource;
if (diagnostics != null)
diagnostics.Trace(this.originalSourceName, traceEvent);
else
source.Trace(traceEvent);
}
}
protected virtual void InvokeTraceWriters(TraceEvent traceEvent)
{
foreach (TraceWriter traceWriter in _innerTraceWriters)
{
// filter based on level before delegating
if (traceWriter.Level >= traceEvent.Level)
{
traceWriter.Trace(traceEvent);
}
}
}
public override void Trace(TraceEvent traceEvent)
{
if (Level < traceEvent.Level)
{
return;
}
if (_predicate(traceEvent))
{
InnerWriter.Trace(traceEvent);
}
}
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);
try
{
if (Events.Count > 1000)
Events.RemoveAt(0);
}
catch (Exception) { }
if (OnEventAdd != null)
OnEventAdd.Invoke(te);
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args)
{
TraceEvent te = new TraceEvent();
te.Cache = eventCache;
te.Source = source;
te.Type = eventType;
te.ID = id;
te.Format = format;
te.Args = args;
Events.Add(te);
if(OnEventAdd != null)
OnEventAdd.Invoke(te);
}
public override void Trace(TraceEvent traceEvent)
{
if (traceEvent == null)
{
throw new ArgumentNullException("traceEvent");
}
// Apply our top level trace filter first
if (Level >= traceEvent.Level)
{
InvokeTraceWriters(traceEvent);
InvokeTextWriter(traceEvent);
}
}
/// <summary>
/// Traces the event.
/// </summary>
/// <param name="eventType">The type of event.</param>
/// <param name="eventId">The event id.</param>
/// <param name="evt">The trace event data.</param>
/// <exception cref="System.ArgumentNullException"><paramref name="evt"/> is a null reference (<b>Nothing</b> in Visual Basic).</exception>
public void TraceEvent(TraceEventType eventType, int eventId, TraceEvent evt)
{
if (evt == null)
{
ThrowHelper.ThrowArgumentNullException("evt");
}
if (!this.InnerSource.Switch.ShouldTrace(eventType))
{
return;
}
this.InnerSource.TraceEvent(eventType, eventId, evt.Serialize());
}
public override void Trace(TraceEvent traceEvent)
{
if (traceEvent == null)
{
throw new ArgumentNullException("traceEvent");
}
foreach (var traceWriter in _innerTraceWriters)
{
if (traceWriter.Level >= traceEvent.Level)
{
traceWriter.Trace(traceEvent);
}
}
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id,
string format, params object[] args)
{
var te = new TraceEvent
{Cache = eventCache, Source = source, Type = eventType, Id = id, Format = format, Args = args};
Events.Add(te);
try
{
if (Events.Count > 1000)
Events.RemoveAt(0);
}
catch(Exception){}
if (OnEventAdd != null)
OnEventAdd.Invoke(te);
}
private static EventSchema CreateEventSchema(TraceEvent traceEvent)
{
return new EventSchema(
(int)traceEvent.ID,
traceEvent.ProviderGuid,
traceEvent.ProviderName,
(EventLevel)traceEvent.Level,
(EventTask)traceEvent.Task,
traceEvent.TaskName,
(EventOpcode)traceEvent.Opcode,
traceEvent.OpcodeName,
(EventKeywords)traceEvent.Keywords,
null, // Keywords description not parsed by DynamicTraceEventParser
traceEvent.Version,
traceEvent.PayloadNames);
}
public GroupPolicyAction(TraceEvent activityStartEvent)
{
ActivityId = activityStartEvent.ActivityID;
Mode =
GroupPolicyDomainKnowledge.MeasurePolicyApplicationMode(
(bool) activityStartEvent.PayloadByName("IsBackgroundProcessing"),
(bool) activityStartEvent.PayloadByName("IsAsyncProcessing"));
Trigger =
GroupPolicyDomainKnowledge.ResolvePolicyApplicationTrigger(
(int) activityStartEvent.ID);
ReasonForSync =
(ReasonForSync) (int) activityStartEvent.PayloadByName("ReasonForSyncProcessing");
Scope =
GroupPolicyDomainKnowledge.MeasureGpoScope(
(int) activityStartEvent.PayloadByName("IsMachine"));
}
public static TraceEvent Create(TraceEventClass eventClass)
{
var trc = new TraceEvent(eventClass);
trc.Columns.Add(TraceColumn.EventClass);
trc.Columns.Add(TraceColumn.EventSubclass);
trc.Columns.Add(TraceColumn.TextData);
trc.Columns.Add(TraceColumn.CurrentTime);
trc.Columns.Add(TraceColumn.Spid);
trc.Columns.Add(TraceColumn.SessionID);
if (eventClass != TraceEventClass.VertiPaqSEQueryCacheMatch)
{
trc.Columns.Add(TraceColumn.StartTime);
}
if (eventClass == TraceEventClass.QueryEnd
|| eventClass == TraceEventClass.CommandEnd
|| eventClass == TraceEventClass.DAXQueryPlan)
{
trc.Columns.Add(TraceColumn.ApplicationName);
}
switch (eventClass)
{
case TraceEventClass.CommandEnd:
case TraceEventClass.CalculateNonEmptyEnd:
case TraceEventClass.DirectQueryEnd:
case TraceEventClass.DiscoverEnd:
case TraceEventClass.ExecuteMdxScriptEnd:
case TraceEventClass.FileSaveEnd:
case TraceEventClass.ProgressReportEnd:
case TraceEventClass.QueryCubeEnd:
case TraceEventClass.QueryEnd:
case TraceEventClass.QuerySubcube:
case TraceEventClass.QuerySubcubeVerbose:
case TraceEventClass.VertiPaqSEQueryEnd:
trc.Columns.Add(TraceColumn.Duration);
trc.Columns.Add(TraceColumn.CpuTime);
break;
case TraceEventClass.Error:
trc.Columns.Add(TraceColumn.Error);
break;
}
return trc;
}
public void RemoveOldEvents_RemovesEventsOutsideWindow()
{
SlidingWindowTraceFilter filter = new SlidingWindowTraceFilter(TimeSpan.FromMinutes(10), 5);
DateTime now = DateTime.UtcNow - TimeSpan.FromMinutes(10);
Assert.Equal(0, filter.Events.Count);
filter.RemoveOldEvents(now);
Assert.Equal(0, filter.Events.Count);
// add some events over a few minutes
for (int i = 0; i < 10; i++)
{
now += TimeSpan.FromMinutes(1);
var traceEvent = new TraceEvent(TraceLevel.Error, string.Format("Error {0}", i))
{
Timestamp = now
};
filter.Events.Add(traceEvent);
}
Assert.Equal(10, filter.Events.Count);
filter.RemoveOldEvents(now);
Assert.Equal(10, filter.Events.Count);
Assert.Equal("Error 0", filter.Events.First().Message);
Assert.Equal("Error 9", filter.Events.Last().Message);
// now advance forward a minute
now += TimeSpan.FromMinutes(1);
filter.RemoveOldEvents(now);
Assert.Equal(9, filter.Events.Count);
Assert.Equal("Error 1", filter.Events.First().Message);
Assert.Equal("Error 9", filter.Events.Last().Message);
// now advance forward a few more minutes
now += TimeSpan.FromMinutes(5);
filter.RemoveOldEvents(now);
Assert.Equal(4, filter.Events.Count);
Assert.Equal("Error 6", filter.Events.First().Message);
Assert.Equal("Error 9", filter.Events.Last().Message);
// finally advance forward past all existing events
now += TimeSpan.FromMinutes(5);
filter.RemoveOldEvents(now);
Assert.Equal(0, filter.Events.Count);
}
public CodeFlowService(
string authorWatch,
string secondAuthorWatch,
int refreshInterval,
int announceInterval,
RawPublishEvent publishEvent,
TraceEvent traceEvent)
{
this.authorWatch = authorWatch;
this.secondAuthorWatch = secondAuthorWatch;
this.refreshInterval = refreshInterval;
this.announceInterval = announceInterval;
this.publishEvent = publishEvent;
this.traceEvent = traceEvent;
this.codeFlowRefreshThread = new Thread(this.RunRefresh) { IsBackground = true };
this.traceEvent.Publish(new TraceMessage { Owner = "CodeFlow", Message = "Ready" });
}
public void EventReceived(TraceEvent traceEvent)
{
var e = context.SqlTraceEvents[traceEvent.EventClass];
var evtCtgr = context.SqlTraceCategories[e.CategoryId];
StringBuilder sb = new StringBuilder();
sb.AppendLine("**********************************************");
sb.AppendFormat("Event Name: {0}\n", e.Name);
sb.AppendFormat("Event Category: {0}\n", evtCtgr.Name);
foreach (var kv in traceEvent.Values)
{
sb.AppendFormat("{0}: {1}\n", context.SqlTraceColumns[kv.Key].Name, kv.Value.ToString());
if (context.SqlTraceColumns[kv.Key].HasSubClassValues && context.SqlTraceEvents[traceEvent.EventClass].SubClassValues.ContainsKey(kv.Key))
{
sb.AppendFormat("{0}_VALUE: {1}\n", context.SqlTraceColumns[kv.Key].Name, context.SqlTraceEvents[traceEvent.EventClass].SubClassValues[kv.Key][(int)kv.Value].Name);
}
}
sb.AppendLine("**********************************************");
sb.AppendLine();
Console.WriteLine(sb.ToString());
}
private void OnEventHelper(TraceEvent data)
{
// Ignore EventTrace events.
if (data.ProviderGuid == EventTraceProviderID)
{
return;
}
// Ignore kernel events.
if (data.ProviderGuid == KernelProviderID)
{
return;
}
// Ignore manifest events.
if ((int)data.ID == 0xFFFE)
{
return;
}
this.OnEvent(new EtwEvent(data));
}
public virtual FilterRuleResult EvaluateEvent(TraceEvent evt)
{
if (FilterRules.Count == 0)
{
return(FilterRuleResult.Include);
}
foreach (var rule in FilterRules)
{
if (rule.IsActive)
{
var result = rule.Evaluate(evt);
if (result != FilterRuleResult.Skip)
{
return(result);
}
}
}
return(DefaultResult);
}
/// <inheritdoc/>
public override bool Filter(TraceEvent traceEvent)
{
if (FilterCore(traceEvent))
{
// Ok to lock here since this filter will generally only be configured to
// fire on errors/warnings, and those events will be rare in normal processing.
lock (_syncLock)
{
RemoveOldEvents(DateTime.Now);
_events.Add(traceEvent);
if (_events.Count >= Threshold)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Collects all progress report end events since the trace was started.
/// </summary>
private static TraceEvent CreateEventProgressReportBegin()
{
var ev = new TraceEvent(TraceEventClass.ProgressReportBegin);
{
#region columns definition
ev.Columns.Add(TraceColumn.EventClass);
ev.Columns.Add(TraceColumn.EventSubclass);
ev.Columns.Add(TraceColumn.CurrentTime);
ev.Columns.Add(TraceColumn.ObjectID);
ev.Columns.Add(TraceColumn.ObjectType);
ev.Columns.Add(TraceColumn.ObjectName);
ev.Columns.Add(TraceColumn.ObjectPath);
ev.Columns.Add(TraceColumn.ObjectReference);
ev.Columns.Add(TraceColumnFilter);
#endregion
}
return(ev);
}
public static bool MatchProcessID(TraceEvent evt, TraceSourceManager source, IList <int> pids)
{
if (!pids.Contains(evt.ProcessID))
{
return(CompareResult.Mismatch);
}
if (!source.IsWindows)
{
// For Linux both pid and tid should match
// Check default payload value
if (!pids.Contains(evt.ThreadID))
{
// Check event-specific payload value
if (!pids.Contains((int)GetPayloadValue(evt, "PayloadThreadID")))
{
return(CompareResult.Mismatch);
}
}
}
return(CompareResult.Match);
}
protected override void EnumerateTemplates(Func <string, string, EventFilterResponse> eventsToObserve, Action <TraceEvent> callback)
{
if (s_templates == null)
{
var templates = new TraceEvent[6];
templates[0] = EventSourceMessageTemplate(null);
templates[1] = EnterTemplate(null);
templates[2] = ExitTemplate(null);
templates[3] = InfoTemplate(null);
templates[4] = ErrorMessageTemplate(null);
templates[5] = CriticalFailureTemplate(null);
s_templates = templates;
}
foreach (var template in s_templates)
{
if (eventsToObserve == null || eventsToObserve(template.ProviderName, template.EventName) == EventFilterResponse.AcceptEvent)
{
callback(template);
}
}
}
void OnDxgkrnlDpiReportAdapter(TraceEvent obj)
{
Debug.Assert(obj.EventName == "DpiReportAdapter" && obj.PayloadNames.Length == 12);
Debug.Assert(obj.PayloadNames[0] == "pDxgAdapter");
ulong pDxgiAdapter = (ulong)obj.PayloadValue(0);
if (!adapterLookup.ContainsKey(pDxgiAdapter))
{
Debug.Assert(false);
return;
}
AdapterInfo adapter = adapterLookup[pDxgiAdapter];
Debug.Assert(obj.PayloadNames[6] == "VendorID");
adapter.VendorID = (int)obj.PayloadValue(6);
Debug.Assert(obj.PayloadNames[11] == "AdapterLuid");
adapter.AdapterLuid = (long)obj.PayloadValue(11);
}
// THis is for the TaskWaitEnd. We want to have a stack event if 'data' does not have one, we lose the fact that
// ANYTHING happened on this thread. Thus we log the stack of the activity so that data does not need a stack.
private void OnTaskUnblock(TraceEvent data)
{
if (m_activityComputer == null)
{
return;
}
TraceThread thread = data.Thread();
if (thread != null)
{
TraceActivity activity = m_activityComputer.GetCurrentActivity(thread);
StackSourceCallStackIndex stackIndex = m_activityComputer.GetCallStackForActivity(m_outputStackSource, activity, GetTopFramesForActivityComputerCase(data, data.Thread()));
m_threadState[(int)thread.ThreadIndex].LogThreadStack(data.TimeStampRelativeMSec, stackIndex, thread, this, onCPU: true);
}
else
{
Debug.WriteLine("Warning, no thread at " + data.TimeStampRelativeMSec.ToString("f3"));
}
}
/// <summary>
/// Returns a StackSourceCallStackIndex representing the call stack from the TraceLog represented by the CallStackIndex 'callStackIndex'.
/// Use the TraceEvent 'data' to find the stack if callStackIndex is invalid.
/// TODO data should be removed (or callstack derived from it)
/// </summary>
public StackSourceCallStackIndex GetCallStack(CallStackIndex callStackIndex, TraceEvent data)
{
if (callStackIndex == CallStackIndex.Invalid)
{
if (data == null)
{
return(StackSourceCallStackIndex.Invalid);
}
var thread = data.Thread();
if (thread == null)
{
return(StackSourceCallStackIndex.Invalid);
}
return(GetCallStackForThread(thread));
}
var idx = (int)StackSourceCallStackIndex.Start + (int)callStackIndex;
return((StackSourceCallStackIndex)idx);
}
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);
}
private void ReadTimeAndSource(StreamReader reader, TraceEvent evt, long fromPosition, long sizeToScan)
{
reader.BaseStream.Seek(fromPosition, SeekOrigin.Begin);
reader.DiscardBufferedData();
char[] buffer = new char[sizeToScan];
int charsRead = reader.ReadBlock(buffer, 0, buffer.Length);
string str = new string(buffer, 0, charsRead);
Match m = Regex.Match(str, @"Time=""(.*?)"".*?Source=""(.*?)""", RegexOptions.IgnoreCase);
if (m != null && m.Success)
{
string dt = m.Groups[1].Value;
DateTime parsedDt;
if (DateTime.TryParse(dt, out parsedDt))
{
evt.TimeCreated = parsedDt;
}
evt.Source = m.Groups[2].Value;
evt.Source = evt.Source.Replace("SendRequest", "").Replace("ReceiveReply", "").Replace("Send", "").Replace("Receive", "");
}
}
private void InternalStart()
{
try
{
while (isRunning && traceConn.HasResults)
{
TraceEvent evt = traceConn.Next();
if (evt != null)
{
queue.Enqueue(evt);
}
}
}
catch (Exception e)
{
if (isRunning && traceConn.HasResults)
{
Console.WriteLine(e.Message);
}
}
}
private void DynamicAllMonitor(TraceEvent obj)
{
// If we are paused, ignore the event.
// There's a potential race here between the two tasks but not a huge deal if we miss by one event.
_renderer.ToggleStatus(pauseCmdSet);
if (obj.EventName.Equals("EventCounters"))
{
IDictionary <string, object> payloadVal = (IDictionary <string, object>)(obj.PayloadValue(0));
IDictionary <string, object> payloadFields = (IDictionary <string, object>)(payloadVal["Payload"]);
// If it's not a counter we asked for, ignore it.
if (!filter.Filter(obj.ProviderName, payloadFields["Name"].ToString()))
{
return;
}
ICounterPayload payload = payloadFields["CounterType"].Equals("Sum") ? (ICounterPayload) new IncrementingCounterPayload(payloadFields, _interval) : (ICounterPayload) new CounterPayload(payloadFields);
_renderer.CounterPayloadReceived(obj.ProviderName, payload, pauseCmdSet);
}
}
public void updateTableRow(TraceEvent data, string PID)
{
DataRow row = dt.Select("PID = '" + PID + "'").FirstOrDefault();
int total;
try
{
Process pname = Process.GetProcessById(Int32.Parse(PID));
if (data.EventName.Contains("Send") || data.EventName.Contains("Reconnect") || data.EventName.Contains("Copy"))
{
row[2] = data.PayloadValue(1);
}
else if (data.EventName.Contains("Recv"))
{
row[3] = data.PayloadValue(1);
}
String bytesSent = row[2].ToString();
String bytesRec = row[3].ToString();
if (bytesRec.Equals(""))
{
bytesRec = "0";
}
if (bytesSent.Equals(""))
{
bytesSent = "0";
}
total = Int32.Parse(bytesSent) + Int32.Parse(bytesRec);
row[4] = total;
int port = Int32.Parse(data.PayloadValue(5).ToString());
if (port < 0)
{
port = port * -1;
}
row[5] = port;
}
catch (ArgumentException e)
{
dt.Rows.Remove(row);
}
}
/// <summary>
/// Log a CPU sample on this thread.
/// </summary>
public void LogCPUSample(
ComputingResourceStateMachine stateMachine,
TraceThread thread,
TraceEvent data)
{
if ((null == stateMachine) || (null == thread) || (null == data))
{
return;
}
StackSourceSample sample = stateMachine.Sample;
sample.Metric = 1;
sample.TimeRelativeMSec = data.TimeStampRelativeMSec;
MutableTraceEventStackSource stackSource = stateMachine.StackSource;
// Attempt to charge the CPU to a request.
CallStackIndex traceLogCallStackIndex = data.CallStackIndex();
ScenarioThreadState scenarioThreadState = stateMachine.Configuration.ScenarioThreadState[ThreadIndex];
StackSourceCallStackIndex callStackIndex = scenarioThreadState.GetCallStackIndex(stackSource, thread, data);
// Add the thread.
StackSourceFrameIndex threadFrameIndex = stackSource.Interner.FrameIntern(thread.VerboseThreadName);
callStackIndex = stackSource.Interner.CallStackIntern(threadFrameIndex, callStackIndex);
// Rest of the stack.
// NOTE: Do not pass a call stack map into this method, as it will skew results.
callStackIndex = stackSource.GetCallStack(traceLogCallStackIndex, callStackIndex, null);
// Add the CPU frame.
StackSourceFrameIndex cpuFrameIndex = stackSource.Interner.FrameIntern("CPU");
callStackIndex = stackSource.Interner.CallStackIntern(cpuFrameIndex, callStackIndex);
// Add the sample.
sample.StackIndex = callStackIndex;
stackSource.AddSample(sample);
}
/// <inheritdoc/>
public override void Trace(TraceEvent traceEvent)
{
if (traceEvent == null)
{
throw new ArgumentNullException("traceEvent");
}
if (ShouldIgnore(traceEvent))
{
return;
}
try
{
if (Filters.Count > 0)
{
foreach (TraceFilter filter in Filters)
{
// trace must be passed to all filters (even if no notifications will be
// performed due to throttling) to allow them to continue to accumulate their results
if (filter.Filter(traceEvent))
{
// Notify all subscribers
Notify(filter);
}
}
}
else
{
// no filters have been configured so notify always
Notify(null);
}
}
catch
{
// Need to prevent infinite loops when calling out to user code
// I.e., user code exception in error handler causes error filter/subscriber
// to be called again.
}
}
// [SecuritySafeCritical]
private void RawDispatch(TraceEventNativeMethods.EVENT_RECORD *rawData)
{
if (stopProcessing)
{
return;
}
if (lockObj != null)
{
Monitor.Enter(lockObj);
}
Debug.Assert(rawData->EventHeader.HeaderType == 0); // if non-zero probably old-style ETW header
// Give it an event ID if it does not have one.
traceLoggingEventId.TestForTraceLoggingEventAndFixupIfNeeded(rawData);
TraceEvent anEvent = Lookup(rawData);
#if DEBUG
anEvent.DisallowEventIndexAccess = DisallowEventIndexAccess;
#endif
// Keep in mind that for UnhandledTraceEvent 'PrepForCallback' has NOT been called, which means the
// opcode, guid and eventIds are not correct at this point. The ToString() routine WILL call
// this so if that is in your debug window, it will have this side effect (which is good and bad)
// Looking at rawData will give you the truth however.
anEvent.DebugValidate();
if (anEvent.NeedsFixup)
{
anEvent.FixupData();
}
Dispatch(anEvent);
if (lockObj != null)
{
Monitor.Exit(lockObj);
}
}
public static EventData ToEventData(this TraceEvent traceEvent, IHealthReporter healthReporter)
{
Debug.Assert(healthReporter != null);
EventData eventData = new EventData
{
ProviderName = traceEvent.ProviderName,
Timestamp = DateTime.UtcNow,
Level = (LogLevel)(int)traceEvent.Level,
Keywords = (long)traceEvent.Keywords
};
IDictionary <string, object> payloadData = eventData.Payload;
payloadData.Add(nameof(traceEvent.ID), (int)traceEvent.ID); // TraceEvent.ID is ushort, not CLS-compliant, so we cast to int
payloadData.Add(nameof(traceEvent.EventName), traceEvent.EventName);
if (traceEvent.ActivityID != default(Guid))
{
payloadData.Add(nameof(traceEvent.ActivityID), ActivityPathDecoder.GetActivityPathString(traceEvent.ActivityID));
}
if (traceEvent.RelatedActivityID != default(Guid))
{
payloadData.Add(nameof(traceEvent.RelatedActivityID), traceEvent.RelatedActivityID.ToString());
}
try
{
// If the event has a badly formatted manifest, the FormattedMessage property getter might throw
string message = traceEvent.FormattedMessage;
if (message != null)
{
payloadData.Add("Message", traceEvent.FormattedMessage);
}
}
catch { }
traceEvent.ExtractPayloadData(eventData, healthReporter);
return(eventData);
}
protected internal override void EnumerateTemplates(Func <string, string, EventFilterResponse> eventsToObserve, Action <TraceEvent> callback)
{
if (s_templates == null)
{
var templates = new TraceEvent[7];
templates[0] = new SettingsTraceData(null, 1, 321, "JSDumpHeapEnvelope", JSDumpHeapEnvelopeTaskGuid, 1, "Start", ProviderGuid, ProviderName);
templates[1] = new SummaryTraceData(null, 2, 321, "JSDumpHeapEnvelope", JSDumpHeapEnvelopeTaskGuid, 2, "Stop", ProviderGuid, ProviderName);
templates[2] = new BulkNodeTraceData(null, 3, 323, "JSDumpHeapBulkNode", JSDumpHeapBulkNodeTaskGuid, 0, "Info", ProviderGuid, ProviderName);
templates[3] = new BulkAttributeTraceData(null, 4, 324, "JSDumpHeapBulkAttribute", JSDumpHeapBulkAttributeTaskGuid, 0, "Info", ProviderGuid, ProviderName);
templates[4] = new BulkEdgeTraceData(null, 5, 325, "JSDumpHeapBulkEdge", JSDumpHeapBulkEdgeTaskGuid, 0, "Info", ProviderGuid, ProviderName);
templates[5] = new StringTableTraceData(null, 6, 326, "JSDumpHeapStringTable", JSDumpHeapStringTableTaskGuid, 0, "Info", ProviderGuid, ProviderName);
templates[6] = new DoubleTableTraceData(null, 7, 327, "JSDumpHeapDoubleTable", JSDumpHeapDoubleTableTaskGuid, 0, "Info", ProviderGuid, ProviderName);
s_templates = templates;
}
foreach (var template in s_templates)
{
if (eventsToObserve == null || eventsToObserve(template.ProviderName, template.EventName) == EventFilterResponse.AcceptEvent)
{
callback(template);
}
}
}
/// <summary>
/// given that 'eventRecord' is a TraceLogging event (with meta-data 'metaData'), return a eventID that is unique
/// to that provider/opcode/meta-data blob.
/// </summary>
private ushort GetEventIDForTraceLoggingEvent(TraceEventNativeMethods.EVENT_RECORD *eventRecord, TraceEventNativeMethods.EVENT_HEADER_EXTENDED_DATA_ITEM *metaData)
{
Debug.Assert(metaData->ExtType == TraceEventNativeMethods.EVENT_HEADER_EXT_TYPE_EVENT_SCHEMA_TL);
if (m_traceLoggingEventMap == null) // Lazy init.
{
m_traceLoggingEventMap = new Dictionary <ProviderMetaDataKey, ushort>();
m_nextTraceLoggingIDForProvider = new Dictionary <Guid, ushort>();
}
// Check if I am in the table of assigned eventIds for this meta-data- blob
ProviderMetaDataKey key = new ProviderMetaDataKey(&eventRecord->EventHeader.ProviderId, eventRecord->EventHeader.Opcode, (byte *)metaData->DataPtr, metaData->DataSize);
ushort ret;
if (!m_traceLoggingEventMap.TryGetValue(key, out ret))
{
// No then get the next ID for this particular provider (and allocate a new one)
m_nextTraceLoggingIDForProvider.TryGetValue(eventRecord->EventHeader.ProviderId, out ret);
ret++;
m_nextTraceLoggingIDForProvider[eventRecord->EventHeader.ProviderId] = ret;
if (ret == 0) // means we wrapped around. We have no more!
{
throw new InvalidOperationException("Error ran out of TraceLogging Event IDs for provider " + eventRecord->EventHeader.ProviderId);
}
// Make a copy of memory the key points at. Thus the table 'owns' the data the keys point at.
// This is reclaimed in 'Dispose'
int copyDataSize = (key.DataSize + 3) & ~3; // round it up to a multiple of 4. CopyBlob requires this.
byte *copy = (byte *)Marshal.AllocHGlobal(copyDataSize + sizeof(Guid));
key.Provider = (Guid *)(copy);
*key.Provider = eventRecord->EventHeader.ProviderId;
copy += sizeof(Guid);
TraceEvent.CopyBlob((IntPtr)key.Data, (IntPtr)copy, copyDataSize);
key.Data = copy;
// Add the new key and eventID to the table.
m_traceLoggingEventMap.Add(key, ret);
}
return(ret);
}
internal unsafe QuicEtwEvent(TraceEvent evt, Timestamp timestamp)
{
Provider = evt.ProviderGuid;
ID = (QuicEventId)evt.ID;
PointerSize = evt.PointerSize;
ProcessId = (uint)evt.ProcessID;
ThreadId = (uint)evt.ThreadID;
Processor = (ushort)evt.ProcessorNumber;
TimeStamp = timestamp;
ObjectType = ComputeObjectType(evt);
var data = new ReadOnlySpan <byte>(evt.DataStart.ToPointer(), evt.EventDataLength);
if (ObjectType != QuicObjectType.Global)
{
ObjectPointer = data.ReadPointer(PointerSize);
Payload = DecodePayload(ID, data, PointerSize);
}
else
{
Payload = DecodePayload(ID, data, PointerSize);
}
}
/// <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());
}
public async Task QueueTriggerToBlobTest()
{
string id = Guid.NewGuid().ToString();
string messageContent = string.Format("{{ \"id\": \"{0}\" }}", id);
CloudQueueMessage message = new CloudQueueMessage(messageContent);
await Fixture.TestQueue.AddMessageAsync(message);
var resultBlob = Fixture.TestContainer.GetBlockBlobReference(id);
string result = await TestHelpers.WaitForBlobAsync(resultBlob);
Assert.Equal(TestHelpers.RemoveByteOrderMarkAndWhitespace(messageContent), TestHelpers.RemoveByteOrderMarkAndWhitespace(result));
TraceEvent scriptTrace = Fixture.TraceWriter.Traces.SingleOrDefault(p => p.Message.Contains(id));
Assert.Equal(TraceLevel.Verbose, scriptTrace.Level);
string trace = scriptTrace.Message;
Assert.True(trace.Contains("script processed queue message"));
Assert.True(trace.Replace(" ", string.Empty).Contains(messageContent.Replace(" ", string.Empty)));
}
public static string ToJSON(TraceEvent data, Type type)
{
//TODO: implement the faster way
//faster way
//http://www.newtonsoft.com/json/help/html/ReadingWritingJSON.htm
//StringWriter sw = new StringWriter();
//using (JsonTextWriter writer = new JsonTextWriter(sw))
//{
// //{
// writer.WriteStartObject();
// writer.WritePropertyName("processId");
// writer.WriteValue(data.ProcessID);
// //...
// writer.WriteEndObject();
// return sw.ToString();
//}
//faster implementation
return(JsonConvert.SerializeObject(data, type, new JsonSerializerSettings()));
}
public void OnEvent(ITraceEvent eventData, CTraceRelogger relogger)
{
var rawData = (TraceEventNativeMethods.EVENT_RECORD *)eventData.GetEventRecord();
var source = m_source;
if (source.stopProcessing)
{
return;
}
// is this the very first event? if so this could be the header event (for real time ETW)
if (m_source._syncTimeQPC == 0)
{
Initialize(rawData);
}
Debug.Assert(rawData->EventHeader.HeaderType == 0); // if non-zero probably old-style ETW header
TraceEvent anEvent = source.Lookup(rawData);
source.m_curITraceEvent = eventData;
source.m_curTraceEventRecord = anEvent.eventRecord;
// Keep in mind that for UnhandledTraceEvent 'PrepForCallback' has NOT been called, which means the
// opcode, guid and eventIds are not correct at this point. The ToString() routine WILL call
// this so if that is in your debug window, it will have this side effect (which is good and bad)
// Looking at rawData will give you the truth however.
anEvent.DebugValidate();
if (anEvent.NeedsFixup)
{
anEvent.FixupData();
}
source.Dispatch(anEvent);
// Release the COM object aggressively Otherwise you build up quite a few of these before
// the GC kicks in and cleans them all up.
Marshal.FinalReleaseComObject(source.m_curITraceEvent);
source.m_curITraceEvent = null;
}
public void Trace_AnonymousFilter_NotifiesAsExpected()
{
TraceFilter filter = null;
var monitor = new TraceMonitor()
.Filter(p =>
{
return(true);
}, "Custom Message")
.Subscribe(p =>
{
filter = p;
});
TraceEvent traceEvent = new TraceEvent(TraceLevel.Error, "Error!");
monitor.Trace(traceEvent);
Assert.Equal("Custom Message", filter.Message);
Assert.Equal(1, filter.Events.Count);
Assert.Same(traceEvent, filter.Events.Single());
}
private void HandleHistogram(TraceEvent obj)
{
string sessionId = (string)obj.PayloadValue(0);
string meterName = (string)obj.PayloadValue(1);
//string meterVersion = (string)obj.PayloadValue(2);
string instrumentName = (string)obj.PayloadValue(3);
string unit = (string)obj.PayloadValue(4);
string tags = (string)obj.PayloadValue(5);
string quantilesText = (string)obj.PayloadValue(6);
if (sessionId != _metricsEventSourceSessionId)
{
return;
}
MeterInstrumentEventObserved(meterName, instrumentName, obj.TimeStamp);
KeyValuePair <double, double>[] quantiles = ParseQuantiles(quantilesText);
foreach ((double key, double val) in quantiles)
{
CounterPayload payload = new PercentilePayload(meterName, instrumentName, null, unit, AppendQuantile(tags, $"Percentile={key*100}"), val, obj.TimeStamp);
_renderer.CounterPayloadReceived(payload, _pauseCmdSet);
}
}
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());
}
}
public static string ToJson(this TraceEvent traceEvent)
{
var names = traceEvent.PayloadNames;
var count = names.Length;
using (var sw = new StringWriter())
using (var jw = new Json.TinyJsonWriter(sw))
{
jw.WriteStartObject();
for (int i = 0; i < count; i++)
{
var name = names[i];
var value = traceEvent.PayloadString(i);
jw.WritePropertyName(name);
jw.WriteValue(value);
}
jw.WriteEndObject();
sw.Flush();
return(sw.ToString());
}
}
