public void WaitForEnable(EventSource logger) { if (!SpinWait.SpinUntil(() => logger.IsEnabled(), TimeSpan.FromSeconds(10))) { throw new InvalidOperationException("EventSource not enabled after 5 seconds"); } }
protected override void OnEventSourceCreated(System.Diagnostics.Tracing.EventSource eventSource) { if (eventSource.Name == "Microsoft-Extensions-Logging") { _loggingEventSource = eventSource; } }
internal void EnableTimer(EventSource eventSource, int pollingTime) { FilteringOptions options = new FilteringOptions(); options.Args = new Dictionary<string, string>(); options.Args.Add("EventCounterIntervalSec", pollingTime.ToString()); EventSourceCommand(eventSource.Name, EventCommand.Enable, options); }
private void EnableSourceIfMatch(EventSource source) { if (_targetSourceName.ContainsKey(source.Name)) { EnableEvents(source, _level); } }
private void Test_BadTypes_Manifest(EventSource source) { try { var listener = new EventListenerListener(); var events = new List<Event>(); Debug.WriteLine("Adding delegate to onevent"); listener.OnEvent = delegate (Event data) { events.Add(data); }; listener.EventSourceCommand(source.Name, EventCommand.Enable); listener.Dispose(); // Confirm that we get exactly one event from this whole process, that has the error message we expect. Assert.Equal(events.Count, 1); Event _event = events[0]; Assert.Equal("EventSourceMessage", _event.EventName); string message = _event.PayloadString(0, "message"); // expected message: "ERROR: Exception in Command Processing for EventSource BadEventSource_Bad_Type_ByteArray: Unsupported type Byte[] in event source. " Assert.True(Regex.IsMatch(message, "Unsupported type")); } finally { source.Dispose(); } }
static ReadOnlyDictionary <int, EventSchemaPortion> GetEventSchemaPortions(System.Diagnostics.Tracing.EventSource source) { return(cache.GetOrAdd(source, s => // no needs lock { var manifest = System.Diagnostics.Tracing.EventSource.GenerateManifest(s.GetType(), null); var xElem = XElement.Parse(manifest); var ns = xElem.Name.Namespace; // { tid : {[payloadNames]}} var tidRef = xElem.Descendants(ns + "template") .ToDictionary(x => x.Attribute("tid").Value, x => new ReadOnlyCollection <string>( x.Elements(ns + "data") .Select(y => y.Attribute("name").Value) .ToArray())); var dict = xElem.Descendants(ns + "event") .ToDictionary(x => int.Parse(x.Attribute("value").Value), x => new EventSchemaPortion( x.Attribute("template")?.Value != null ? tidRef[x.Attribute("template").Value] : new string[0].ToList().AsReadOnly(), x.Attribute("keywords")?.Value ?? "", x.Attribute("task")?.Value ?? x.Attribute("symbol").Value)); return new ReadOnlyDictionary <int, EventSchemaPortion>(dict); })); }
private void EnableSourceIfMatch(EventSource source) { if (source.Name.Equals(_targetSourceName) || source.Guid.Equals(_targetSourceGuid)) { EnableEvents(source, _level); } }
protected override void OnEventSourceCreated(System.Diagnostics.Tracing.EventSource eventSource) { if (eventSource.Name == "Microsoft-Extensions-Logging") { DisableEvents(eventSource); EnableEvents(eventSource, EventLevel.Verbose, _keywords); } }
protected override void OnEventSourceCreated(EventSource eventSource) { // Check for null because this method is called by the base class constror before we can initialize it Action<EventSource> callback = this.OnOnEventSourceCreated; if (callback != null) { callback(eventSource); } }
/// <summary>Called for all existing event sources when the event listener is created and when a new event /// source is attached to the listener. Enables log sources to the appropriate event level.</summary> /// <param name="eventSource">The event source.</param> protected override void OnEventSourceCreated(EventSource eventSource) { var log = eventSource as Log; if (log != null) { this.EnableEvents(log, this.eventLevel); } }
public EventProviderSubscription(EventSource source) { if (source == null) { throw new ArgumentNullException("source"); } this.Source = source; }
protected override void OnEventSourceCreated(EventSource eventSource) { base.OnEventSourceCreated(eventSource); if (eventSource.Name.Equals(Constants.LogSourceName)) { this.EnableEvents(eventSource, EventLevel.Verbose); } }
/// <summary> /// Enables HTTP event source when EventSource is created. Called for all existing /// event sources when the event listener is created and when a new event source is attached to the listener. /// </summary> protected override void OnEventSourceCreated(EventSource eventSource) { if (eventSource != null && eventSource.Name == FrameworkEventSourceName) { this.EnableEvents(eventSource, EventLevel.Informational, (EventKeywords)4); DependencyCollectorEventSource.Log.RemoteDependencyModuleVerbose("HttpEventListener initialized for event source:" + FrameworkEventSourceName); } base.OnEventSourceCreated(eventSource); }
protected override void OnEventSourceCreated(EventSource eventSource) { if (_providers == null) { _eventSourcesToEnable.Add(eventSource); } if (IsIntendedEventSource(eventSource)) { this.EnableEvents(eventSource, EventLevel.LogAlways); } }
protected override void OnEventSourceCreated(System.Diagnostics.Tracing.EventSource eventSource) { if (eventSource.Name == "Microsoft-Extensions-Logging") { _loggingEventSource = eventSource; } if (_enableWhenCreated != null) { EnableEvents(_loggingEventSource, _enableWhenCreated.Level, _enableWhenCreated.Keywords, GetArguments(_enableWhenCreated)); _enableWhenCreated = null; } }
/// <summary> /// Gets the <see cref="EventSchema"/> for the specified eventId and eventSource. /// </summary> /// <param name="eventId">The ID of the event.</param> /// <param name="eventSource">The event source.</param> /// <returns>The EventSchema.</returns> public EventSchema GetSchema(int eventId, EventSource eventSource) { Guard.ArgumentNotNull(eventSource, "eventSource"); IReadOnlyDictionary<int, EventSchema> events; if (!this.schemas.TryGetValue(eventSource.Guid, out events)) { events = new ReadOnlyDictionary<int, EventSchema>(this.schemaReader.GetSchema(eventSource)); this.schemas[eventSource.Guid] = events; } return events[eventId]; }
public void Test_EventSource_Traits_Dynamic() { TestUtilities.CheckNoEventSourcesRunning("Start"); using (var mySource = new EventSource("DynamicEventSourceWithTraits", EventSourceSettings.Default, "MyTrait", "MyTraitValue", "ETW_GROUP", "{4f50731a-89cf-4782-b3e0-dce8c90476ba}")) { // By default we are self-describing. Assert.Equal(mySource.Settings, EventSourceSettings.EtwSelfDescribingEventFormat); Assert.Equal(mySource.GetTrait("MyTrait"), "MyTraitValue"); Assert.Equal(mySource.GetTrait("ETW_GROUP"), "{4f50731a-89cf-4782-b3e0-dce8c90476ba}"); } TestUtilities.CheckNoEventSourcesRunning("Stop"); }
protected override void OnEventSourceCreated(EventSource eventSource) { List<EventSource> tmp = _tmpEventSourceList; if (tmp != null) { lock (tmp) { if (_tmpEventSourceList != null) { _tmpEventSourceList.Add(eventSource); return; } } } EnableSourceIfMatch(eventSource); }
public static void With2Listeners(EventSource logger, Action<ObservableEventListener, ObservableEventListener> scenario) { using (var listener1 = new ObservableEventListener()) using (var listener2 = new ObservableEventListener()) { try { scenario(listener1, listener2); } finally { try { listener1.DisableEvents(logger); } catch { } try { listener2.DisableEvents(logger); } catch { } } } }
public void EnableEvents(EventSource eventSource, EventLevel level, EventKeywords matchAnyKeyword, IDictionary <string, string> arguments) { }
/// <summary> /// This method is called whenever a new eventSource is 'attached' to the dispatcher. /// This can happen for all existing EventSources when the EventListener is created /// as well as for any EventSources that come into existance after the EventListener /// has been created. /// /// These 'catch up' events are called during the construction of the EventListener. /// Subclasses need to be prepared for that. /// /// In a multi-threaded environment, it is possible that 'OnEventWritten' callbacks /// for a paritcular eventSource to occur BEFORE the OnEventSourceCreated is issued. /// </summary> /// <param name="eventSource"></param> internal protected virtual void OnEventSourceCreated(EventSource eventSource) { }
/// <summary> /// Send a command to a particular EventSource identified by 'eventSource' /// /// Calling this routine simply forwards the command to the EventSource.OnEventCommand /// callback. What the EventSource does with the command and its arguments are from that point /// EventSource-specific. /// /// The eventSource is passed the EventListener that issued the command along with the command and /// arguments. The contract is that to the extent possible the eventSource should not affect other /// EventListeners (eg filtering events), however sometimes this simply is not possible (if the /// command was to provoke a GC, or a System flush etc). /// </summary> public static void SendCommand(EventSource eventSource, EventCommand command, IDictionary<string, string> commandArguments) { if (eventSource == null) throw new ArgumentNullException(nameof(eventSource)); // User-defined EventCommands should not conflict with the reserved commands. if ((int)command <= (int)EventCommand.Update && (int)command != (int)EventCommand.SendManifest) throw new ArgumentException(SR.ArgumentOutOfRange_NeedPosNum, nameof(command)); eventSource.SendCommand(null, command, true, EventLevel.LogAlways, EventKeywords.None, commandArguments); }
// We don't expose a Dispose(bool), because the contract is that you don't have any non-syncronous // 'cleanup' associated with this object /// Enable all events from the curEventSource identified by 'eventSource' to the current dispatcher that have a /// verbosity level of 'level' or lower. /// /// This call can have the effect of REDUCING the number of events sent to the dispatcher if 'level' /// indicates a less verbose level than was previously enabled. /// /// This call never has an effect on other EventListeners. /// /// Returns 'true' if any curEventSource could be found that matches 'eventSourceGuid' /// </summary> public void EnableEvents(EventSource eventSource, EventLevel level) { EnableEvents(eventSource, level, EventKeywords.None); }
/// <summary> /// Enable all events from the eventSource identified by 'eventSource' to the current dispatcher that have a /// verbosity level of 'level' or lower and have a event keyword matching any of the bits in /// 'machAnyKeyword' as well as any (curEventSource specific) effect passing addingional 'key-value' arguments /// 'arguments' might have. /// /// This call can have the effect of REDUCING the number of events sent to the dispatcher if 'level' /// indicates a less verbose level than was previously enabled or if 'machAnyKeyword' has fewer /// keywords set than where previously set. /// /// This call never has an effect on other EventListeners. /// </summary> public void EnableEvents(EventSource eventSource, EventLevel level, EventKeywords matchAnyKeyword, IDictionary<string, string> arguments) { if (eventSource == null) { throw new ArgumentNullException(nameof(eventSource)); } Contract.EndContractBlock(); eventSource.SendCommand(this, EventCommand.Update, true, level, matchAnyKeyword, arguments); }
protected unsafe void WriteEventCore(int eventId, int eventDataCount, EventSource.EventData* data) { if (m_eventData != null) { if (m_eventData[eventId].EnabledForETW) { EventProvider.EventData* dataDescrs = stackalloc EventProvider.EventData[eventDataCount]; if (eventDataCount <= 0) { // EventWrite expects NULL if dataDescrs is zero. // You cannot pass a ptr to an empty array. dataDescrs = (EventProvider.EventData*)IntPtr.Zero; } for (int i = 0; i < eventDataCount; i++) { dataDescrs[i].Size = (uint)data[i].Size; dataDescrs[i].Ptr = (ulong)(data[i].DataPointer.ToInt64()); dataDescrs[i].Reserved = 0; } if (!m_provider.WriteEvent(ref m_eventData[eventId].Descriptor, eventDataCount, (IntPtr)dataDescrs) && m_throwOnEventWriteErrors) throw new EventSourceException(); } if (m_Dispatchers != null && m_eventData[eventId].EnabledForAnyListener) { object[] args = new object[eventDataCount]; for (int i = 0; i < eventDataCount; i++) { args[i] = DecodeObject(eventId, i, data[i].Size, data[i].DataPointer); } WriteToAllListeners(eventId, args); } } }
internal protected override void OnEventSourceCreated(EventSource eventSource) { string eventSourceFilter = eventSourceNameFilter.Value; if (String.IsNullOrEmpty(eventSourceFilter) || (eventSource.Name.IndexOf(eventSourceFilter, StringComparison.OrdinalIgnoreCase) >= 0)) { EnableEvents(eventSource, EventLevel.LogAlways, EventKeywords.All, null); } }
internal CounterGroup(EventSource eventSource) { _eventSource = eventSource; _counters = new List <DiagnosticCounter>(); RegisterCommandCallback(); }
public void EnableEvents(EventSource eventSource, EventLevel level) { }
internal EventWrittenEventArgs(EventSource eventSource) { this.m_eventSource = eventSource; }
protected internal virtual void OnEventSourceCreated(EventSource eventSource) { }
public void DisableEvents(EventSource eventSource) { }
internal protected override void OnEventSourceCreated(EventSource eventSource) { EnableEvents(eventSource, EventLevel.LogAlways, EventKeywords.All, null); }
protected override void OnEventSourceCreated(EventSource eventSource) { if (eventSource.Name == "Microsoft-Diagnostics-DiagnosticSource") _diagnosticSourceEventSource = eventSource; }
// Token: 0x0600350E RID: 13582 RVA: 0x000CDDB2 File Offset: 0x000CBFB2 public void Write <T>(EventSource source, string eventName, EventSourceOptions options, T data) { this.Write <T>(source, eventName, ref options, ref data); }
// Token: 0x060033ED RID: 13293 RVA: 0x000C985C File Offset: 0x000C7A5C internal EventCommandEventArgs(EventCommand command, IDictionary <string, string> arguments, EventSource eventSource, EventListener listener, int perEventSourceSessionId, int etwSessionId, bool enable, EventLevel level, EventKeywords matchAnyKeyword) { this.Command = command; this.Arguments = arguments; this.eventSource = eventSource; this.listener = listener; this.perEventSourceSessionId = perEventSourceSessionId; this.etwSessionId = etwSessionId; this.enable = enable; this.level = level; this.matchAnyKeyword = matchAnyKeyword; }
/// <summary> /// All Counters live as long as the EventSource that they are attached to unless they are /// explicitly Disposed. /// </summary> /// <param name="Name">The name.</param> /// <param name="EventSource">The event source.</param> internal DiagnosticCounter(string Name, EventSource EventSource) { this.Name = Name ?? throw new ArgumentNullException(nameof(Name)); this.EventSource = EventSource ?? throw new ArgumentNullException(nameof(EventSource)); }
internal EventCommandEventArgs(EventCommand command, IDictionary<string, string> arguments, EventSource eventSource, EventDispatcher dispatcher) { this.Command = command; this.Arguments = arguments; this.eventSource = eventSource; this.dispatcher = dispatcher; }
/// <summary> /// Enable all events from the eventSource identified by 'eventSourceGuid' to the current dispatcher that have a /// verbosity level of 'level' or lower and have a event keyword matching any of the bits in /// 'machAnyKeyword'. /// /// This call can have the effect of REDUCING the number of events sent to the dispatcher if 'level' /// indicates a less verbose level than was previously enabled or if 'machAnyKeyword' has fewer /// keywords set than where previously set. /// /// If eventSourceGuid is Guid.Empty, then the affects all eventSources in the appdomain /// /// If eventSourceGuid is not Guid.Empty, this call has no effect on any other eventSources in the appdomain. /// /// This call never has an effect on other EventListeners. /// /// Returns 'true' if any eventSource could be found that matches 'eventSourceGuid' /// </summary> public void EnableEvents(EventSource eventSource, EventLevel level, EventKeywords matchAnyKeyword) { EnableEvents(eventSource, level, matchAnyKeyword, null); }
/// <summary> /// Initializes a new instance of the <see cref="IncrementingEventCounter"/> class. /// IncrementingEventCounter live as long as the EventSource that they are attached to unless they are /// explicitly Disposed. /// </summary> /// <param name="name">The name.</param> /// <param name="eventSource">The event source.</param> public IncrementingEventCounter(string name, EventSource eventSource) : base(name, eventSource) { Publish(); }
/// <summary> /// Disables all events coming from eventSource identified by 'eventSource'. /// /// If eventSourceGuid is Guid.Empty, then the affects all eventSources in the appdomain /// /// This call never has an effect on other EventListeners. /// </summary> public void DisableEvents(EventSource eventSource) { if (eventSource == null) { throw new ArgumentNullException(nameof(eventSource)); } Contract.EndContractBlock(); eventSource.SendCommand(this, EventCommand.Update, false, EventLevel.LogAlways, EventKeywords.None, null); }
public EventCounter(string name, System.Diagnostics.Tracing.EventSource eventSource) { }
/// <summary> /// EventSourceIndex is small non-negative integer (suitable for indexing in an array) /// identifying EventSource. It is unique per-appdomain. Some EventListeners might find /// it useful to store addditional information about each eventSource connected to it, /// and EventSourceIndex allows this extra infomation to be efficiently stored in a /// (growable) array (eg List(T)). /// </summary> static protected int EventSourceIndex(EventSource eventSource) { return eventSource.m_id; }
public static int EventSourceIndex(EventSource eventSource) { return(0); }
/// <summary> /// This routine adds newEventSource to the global list of eventSources, it also assigns the /// ID to the eventSource (which is simply the oridinal in the global list). /// /// EventSources currently do not pro-actively remove themselves from this list. Instead /// when eventSources's are GCed, the weak handle in this list naturally gets nulled, and /// we will reuse the slot. Today this list never shrinks (but we do reuse entries /// that are in the list). This seems OK since the expectation is that EventSources /// tend to live for the lifetime of the appdomain anyway (they tend to be used in /// global variables). /// </summary> /// <param name="newEventSource"></param> internal static void AddEventSource(EventSource newEventSource) { lock (EventListenersLock) { if (s_EventSources == null) s_EventSources = new List<WeakReference>(2); // Periodically search the list for existing entries to reuse, this avoids // unbounded memory use if we keep recycling eventSources (an unlikely thing). int newIndex = -1; if (s_EventSources.Count % 64 == 63) // on every block of 64, fill up the block before continuing { int i = s_EventSources.Count; // Work from the top down. while (0 < i) { --i; WeakReference weakRef = s_EventSources[i]; if (!weakRef.IsAlive) { newIndex = i; weakRef.Target = newEventSource; break; } } } if (newIndex < 0) { newIndex = s_EventSources.Count; s_EventSources.Add(new WeakReference(newEventSource)); } newEventSource.m_id = newIndex; // Add every existing dispatcher to the new EventSource for (EventListener listener = s_Listeners; listener != null; listener = listener.m_Next) newEventSource.AddListener(listener); Validate(); } }
public void EnableEvents(EventSource eventSource, EventLevel level, EventKeywords matchAnyKeyword) { }
internal EventWrittenEventArgs(EventSource eventSource) { m_eventSource = eventSource; }
public static void SendCommand(EventSource eventSource, EventCommand command, IDictionary <string, string> commandArguments) { throw new NotImplementedException(); }
public OverideEventProvider(EventSource eventSource) { this.m_eventSource = eventSource; }
protected override void OnEventSourceCreated(EventSource eventSource) { base.OnEventSourceCreated(eventSource); EnableEvents(eventSource, EventLevel.LogAlways, EventKeywords.All); }
unsafe void EtwEnableCallBack( [In] ref System.Guid sourceId, [In] int controlCode, [In] byte setLevel, [In] long anyKeyword, [In] long allKeyword, [In] UnsafeNativeMethods.ManifestEtw.EVENT_FILTER_DESCRIPTOR *filterData, [In] void *callbackContext ) { ControllerCommand command = ControllerCommand.Update; IDictionary <string, string> args = null; byte[] data; int keyIndex; bool skipFinalOnControllerCommand = false; EventSource.OutputDebugString(string.Format("EtwEnableCallBack(ctrl {0}, lvl {1}, any {2:x}, all {3:x})", controlCode, setLevel, anyKeyword, allKeyword)); if (controlCode == UnsafeNativeMethods.ManifestEtw.EVENT_CONTROL_CODE_ENABLE_PROVIDER) { m_enabled = true; m_level = setLevel; m_anyKeywordMask = anyKeyword; m_allKeywordMask = allKeyword; List <Tuple <SessionInfo, bool> > sessionsChanged = GetSessions(); foreach (var session in sessionsChanged) { int sessionChanged = session.Item1.sessionIdBit; int etwSessionId = session.Item1.etwSessionId; bool bEnabling = session.Item2; EventSource.OutputDebugString(string.Format(CultureInfo.InvariantCulture, "EtwEnableCallBack: session changed {0}:{1}:{2}", sessionChanged, etwSessionId, bEnabling)); skipFinalOnControllerCommand = true; args = null; // reinitialize args for every session... // if we get more than one session changed we have no way // of knowing which one "filterData" belongs to if (sessionsChanged.Count > 1) { filterData = null; } // read filter data only when a session is being *added* if (bEnabling && GetDataFromController(etwSessionId, filterData, out command, out data, out keyIndex)) { args = new Dictionary <string, string>(4); while (keyIndex < data.Length) { int keyEnd = FindNull(data, keyIndex); int valueIdx = keyEnd + 1; int valueEnd = FindNull(data, valueIdx); if (valueEnd < data.Length) { string key = System.Text.Encoding.UTF8.GetString(data, keyIndex, keyEnd - keyIndex); string value = System.Text.Encoding.UTF8.GetString(data, valueIdx, valueEnd - valueIdx); args[key] = value; } keyIndex = valueEnd + 1; } } // execute OnControllerCommand once for every session that has changed. try { OnControllerCommand(command, args, (bEnabling ? sessionChanged : -sessionChanged), etwSessionId); } catch (Exception) { // We want to ignore any failures that happen as a result of turning on this provider as to // not crash the app. } } } else if (controlCode == UnsafeNativeMethods.ManifestEtw.EVENT_CONTROL_CODE_DISABLE_PROVIDER) { m_enabled = false; m_level = 0; m_anyKeywordMask = 0; m_allKeywordMask = 0; m_liveSessions = null; } else if (controlCode == UnsafeNativeMethods.ManifestEtw.EVENT_CONTROL_CODE_CAPTURE_STATE) { command = ControllerCommand.SendManifest; } else { return; // per spec you ignore commands you don't recognise. } try { if (!skipFinalOnControllerCommand) { OnControllerCommand(command, args, 0, 0); } } catch (Exception) { // We want to ignore any failures that happen as a result of turning on this provider as to // not crash the app. } }