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