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

 public void WaitForEnable(EventSource logger)
 {
     if (!SpinWait.SpinUntil(() => logger.IsEnabled(), TimeSpan.FromSeconds(10)))
     {
         throw new InvalidOperationException("EventSource not enabled after 5 seconds");
     }
 }

 private void EnableSourceIfMatch(EventSource source)
 {
     if (_targetSourceName.ContainsKey(source.Name))
     {
         EnableEvents(source, _level);
     }
 }

 private void EnableSourceIfMatch(EventSource source)
 {
     if (source.Name.Equals(_targetSourceName) || 
         source.Guid.Equals(_targetSourceGuid))
     {
         EnableEvents(source, _level);
     }
 }

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

        protected override void OnEventSourceCreated(EventSource eventSource)
        {
            base.OnEventSourceCreated(eventSource);

            if (eventSource.Name.Equals(Constants.LogSourceName))
            {
                this.EnableEvents(eventSource, EventLevel.Verbose);
            }
        }

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

        public EventProviderSubscription(EventSource source)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            this.Source = source;
        }

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

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

        /// <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];
        }

        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
                    { }
                }
            }
        }

        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 EventWrittenEventArgs(EventSource eventSource)
 {
     m_eventSource = 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>
        /// 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();
            }
        }

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