internal static void EnableProvider(
            TraceEventSession session,
            Guid providerId,
            EventLevel level,
            EventKeywords matchAnyKeyword,
            IEnumerable<KeyValuePair<string, string>> arguments,
            IEnumerable<string> processNamesToFilter,
            bool sendManifest = true)
        {
            // Make explicit the invocation for requesting the manifest from the EventSource (Provider).
            var argumentsDictionary = arguments.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
            if (sendManifest)
            {
                argumentsDictionary["Command"] = "SendManifest";
            }

            var options =
                new TraceEventProviderOptions
                {
                    Arguments = argumentsDictionary,
                    ProcessNameFilter = processNamesToFilter.ToArray()
                };

            session.EnableProvider(providerId, (TraceEventLevel)level, (ulong)matchAnyKeyword, options);
        }

        private ActionResult Add(string projectId, int? transitionId, EventLevel level, EventType eventType, AppUser creator, object item, DateTime? createdOn = null)
        {
            try
            {
                var i = new ProjectHistory
                {
                    CreatedBy = creator,
                    CreatedOn = createdOn ?? DateTime.UtcNow,
                    Description = JsonConvert.SerializeObject(item),
                    Level = level,
                    ProjectId = projectId,
                    TransitionId = transitionId,
                    Type = eventType
                };

                if (!_dbContext.ChangeTracker.Entries().Where(e => e.State != EntityState.Unchanged).Any())
                {
                    _dbContext.ProjectHistory.Add(i);
                    _dbContext.SaveChanges();
                }
                else
                {
                    _dbContext.ProjectHistory.Add(i);
                }

                return ActionResult.Success(item);
            }
            catch(Exception ex)
            {
                return ActionResult.Failed(ex);
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="EventSourceSettings" /> class.
        /// </summary>
        /// <param name="name">The friendly event source name.</param>
        /// <param name="eventSourceId">The event source id.</param>
        /// <param name="level">The level.</param>
        /// <param name="matchAnyKeyword">The match any keyword.</param>
        /// <param name="arguments">The arguments for the event source.</param>
        /// <param name="processNameFilters">The the process filters.</param>
        /// <exception cref="ConfigurationException">A validation exception.</exception>
        public EventSourceSettings(
            string name = null,
            Guid? eventSourceId = null,
            EventLevel level = EventLevel.LogAlways,
            EventKeywords matchAnyKeyword = Keywords.All,
            IEnumerable<KeyValuePair<string, string>> arguments = null,
            IEnumerable<string> processNameFilters = null)
        {
            // If no Id, Name should not be optional so we may derive an Id from it.
            if (!eventSourceId.HasValue || eventSourceId == Guid.Empty)
            {
                if (string.IsNullOrWhiteSpace(name))
                {
                    throw new ConfigurationException(Properties.Resources.MissingEventSourceNameAndId);
                }

                eventSourceId = TraceEventProviders.GetEventSourceGuidFromName(name);
            }
            else if (!string.IsNullOrWhiteSpace(name))
            {
                // throw and both name & Id specified
                throw new ConfigurationException(Properties.Resources.EventSourceAmbiguityError);
            }

            this.EventSourceId = eventSourceId.Value;
            this.Name = name ?? eventSourceId.ToString(); // Set a not null value for later use
            this.Level = level;
            this.MatchAnyKeyword = matchAnyKeyword;
            this.Arguments = arguments ?? Enumerable.Empty<KeyValuePair<string, string>>();
            this.ProcessNamesToFilter = processNameFilters ?? Enumerable.Empty<string>();
        }

 /// <summary>
 /// Initializes the ConsoleLogListener.
 /// </summary>
 /// <param name="eventLevel">The event level.</param>
 public static void Initialize(EventLevel eventLevel)
 {
     if (instance == null)
     {
         instance = new ConsoleLogListener(eventLevel);
     }
 }

        public override Task<bool> Start()
        {
            // Load the trace level if specified
            string levelStr = GetConfigurationSetting("Trace.Level");
            EventLevel level;
            if (!String.IsNullOrEmpty(levelStr) && Enum.TryParse<EventLevel>(levelStr, true, out level))
            {
                TraceLevel = level;
            }
            else
            {
                TraceLevel = EventLevel.Warning;
            }

            RoleEnvironment.Changing += (_, __) => ConfigurationChanging();
            RoleEnvironment.Changed += (_, __) => ConfigurationChanging();
            RoleEnvironment.StatusCheck += (sender, e) =>
            {
                if (GetCurrentStatus() == ServiceStatus.Busy)
                {
                    e.SetBusy();
                }
            };

            return base.Start();
        }

 protected void OnProcessEvent(EventLevel eventLevel, string message)
 {
     if (ProcessEventOccurred != null)
     {
         ProcessEventOccurred(this, new ProcessEventArgs(DateTime.Now, message, eventLevel));
     }
 }

        internal static void EnableProvider(TraceEventSession session, Guid providerId, EventLevel level, EventKeywords matchAnyKeyword, bool sendManifest = true)
        {
            // Make explicit the invocation for requesting the manifest from the EventSource (Provider).
            var values = sendManifest ? new Dictionary<string, string>() { { "Command", "SendManifest" } } : null;

            session.EnableProvider(providerId, (TraceEventLevel)level, (ulong)matchAnyKeyword, 0, TraceEventOptions.None, values);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="EventTextFormatter" /> class.
 /// </summary>
 /// <param name="header">The header.</param>
 /// <param name="footer">The footer.</param>
 /// <param name="verbosityThreshold">The verbosity threshold.</param>
 /// <param name="dateTimeFormat">The date time format used for timestamp value.</param>
 public EventTextFormatter(string header = null, string footer = null, EventLevel verbosityThreshold = DefaultVerbosityThreshold, string dateTimeFormat = null)
 {
     this.Header = header;
     this.Footer = footer;
     this.VerbosityThreshold = verbosityThreshold;
     this.DateTimeFormat = dateTimeFormat;
 }

 public static void EnableEvents(this EventListener self, IEnumerable<EventSource> sources, EventLevel level)
 {
     foreach (var source in sources)
     {
         self.EnableEvents(source, level);
     }
 }

        internal TraceLoggingTypeInfo(
            Type dataType,
            string name,
            EventLevel level,
            EventOpcode opcode,
            EventKeywords keywords,
            EventTags tags)
        {
            if (dataType == null)
            {
                throw new ArgumentNullException("dataType");
            }

            if (name == null)
            {
                throw new ArgumentNullException("eventName");
            }

            Contract.EndContractBlock();

            Statics.CheckName(name);

            this.name = name;
            this.keywords = keywords;
            this.level = level;
            this.opcode = opcode;
            this.tags = tags;
            this.dataType = dataType;
        }

        public TestEventListener(string taretSourceName, EventLevel level)
        {
            // Store the arguments
            _targetSourceName = taretSourceName;
            _level = level;

            LoadSourceList();
        }

        private ErrorLevel GetLogLevel(EventLevel level)
        {
            ErrorLevel mappedLevel;
            if (LevelMap.TryGetValue(level, out mappedLevel))
                return mappedLevel;

            return ErrorLevel.Debug;
        }

 public bool IsEnabled(EventLevel level, EventKeywords keywords)
 {
     if (!m_providerEnabled) 
         return false;
     if (m_level != 0 && m_level < level) 
         return false; 
     return m_matchAnyKeyword == 0 || (keywords & m_matchAnyKeyword) != 0;
 } 

        public void WriteMessage(string eventMessage, EventLevel level, EventKeywords keywords) 
        {
#if ETW_SUPPORTED 
            if(m_provider != null) 
                m_provider.WriteMessageEvent(eventMessage, (byte)level, (long)keywords);
#endif 
            WriteToAllStreams(0, eventMessage);
        }

		/// <summary>
		/// Initializes a new instance of <see cref="DiagnosticsEventArgs" /> class.
		/// </summary>
		/// <param name="level">The level of the event.</param>
		/// <param name="message">The message of the event.</param>
		/// <param name="source">The source of the event.</param>
		public DiagnosticsEventArgs(EventLevel level, String message, String source)
		{
			Level = level;

			Message = message;

			Source = source;
		}

 public ConsoleColor? Map(EventLevel eventLevel)
 {
     if (eventLevel == EventLevel.Error)
     {
         this.Color = Error;
     }
     return this.Color;
 }

 public void VerifyEvent(ClientEventId id, EventLevel level, EventKeywords keywords, EventOpcode opcode, params object[] payloadItems)
 {
     Assert.Equal(1, this.Events.Count);
     Assert.Equal((int)id, this.Events[0].EventId);
     Assert.Equal(level, this.Events[0].Level);
     Assert.Equal(opcode, this.Events[0].Opcode);
     Assert.True(this.Events[0].Keywords.HasFlag(keywords));
     Assert.Equal(payloadItems, this.Events[0].Payload.ToArray());
 }

 public bool IsEnabled(EventLevel level, EventKeywords keywords)
 {
     if (!m_eventSourceEnabled)
         return false;
     if (m_level != 0 && m_level < level)
         return false;
     if (m_matchAnyKeyword != 0 && (keywords & m_matchAnyKeyword) == 0)
         return false;
     return true;
 }

        public EventLevel GetLogLevel()
        {
            const string Key = "IOT_LOGLEVEL";
            object logLevel = Environment.GetEnvironmentVariable(Key);
            if (logLevel != null)
            {
                _eventLevel = ConfigurationHelper.ConvertValue<EventLevel>(Key, logLevel);
            }

            return _eventLevel;
        }

        public TestEventListener(List<string> targetSourceNames, EventLevel level)
        {
            // Store the arguments
            foreach (var targetSourceName in targetSourceNames)
            {
                _targetSourceName.Add(targetSourceName, true);
            }
            _level = level;

            LoadSourceList();
        }