public void should_limit_requests_to_fifty() { var config = new DiagnosticsConfiguration(); _registry .Services(x => { config = x.FindAllValues<DiagnosticsConfiguration>().First(); }); _registry.BuildGraph(); config.MaxRequests.ShouldEqual(50); }
void ProcessDiagnosticEventInternal(IDiagnosticEvent de, DiagnosticsConfiguration config_ref) { // NOTE: This method is *performance critical* and should be optimized for quickest execution even at cost of readability try { if (!config_ref.Settings.EnableLogging) return; //# Include Caller Info if (config_ref.Settings.IncludeCallerInfo || config_ref.Settings.UseCallerNameAsLoggerName) { de.IncludeCallerInformation( config_ref.Settings.UseCallerNameAsLoggerName, config_ref.Settings.IncludeCallerInfo); } //# Override logger name only if it has not already been set (custom name might have been used) if (de.LoggerName == null) de.LoggerName = Name.ToString(); //# COPY GLOBAL PROPERTIES de.Properties.AddOrUpdateRange(GlobalProperties); //# EVALUATE AND PIN DIAGNOSTIC EVENT DATA de.EvaluateAndPinAllDataIfNeeded(); //# GLOBAL FILTER //! Filtering on a global level must happen *after* logger name is set and properties pinned //! This is because filters are most likely use their values if (!MeetsFiltersCriteria(de, Name, config_ref.GlobalFilters)) return; //# GET SINKS // only use sinks which meet filtering criteria for this event var mustWaitForWriteSinks = (from s in config_ref.Sinks.MustWaitForWriteSinks where s.Filter.Evaluate(de, Name) select s).ToArray(); var fireAndForgetSinks = (from s in config_ref.Sinks.FireAndForgetSinks where s.Filter.Evaluate(de, Name) select s).ToArray(); var allSinks = mustWaitForWriteSinks.Concat(fireAndForgetSinks).ToArray(); //# REQUESTED CONTEXT DATA // get requested context data (requested by sinks via formatters) var isAdditionalContextDataRequested = false; var allRequestedContextData = new List<IDataRequest>(capacity: 27); for(int sink_ix = 0; sink_ix < allSinks.Length; sink_ix++) { var sink = allSinks[sink_ix]; var requestedContextData = sink.GetRequestedContextData(); for(int cd_ix = 0; cd_ix < requestedContextData.Count; cd_ix++) { var cd = requestedContextData[cd_ix]; allRequestedContextData.Add(cd); if (cd.Data == "Event.AdditionalContextData") isAdditionalContextDataRequested = true; } } allRequestedContextData = allRequestedContextData.Distinct().ToList(); // todo: check if performance of distinct is good enough //# INCLUDE DATA REQUESTED BY SINKS var requestedData = config_ref.ContextDataCollectors.Collect(allRequestedContextData); de.Properties.AddOrUpdateRange(requestedData); //# GET ADDITIONAL CONTEXT INFORMATION if (isAdditionalContextDataRequested) { var additionalContextdataCollectors = config_ref.AdditionalContextDataCollectors; for (int i = 0; i < additionalContextdataCollectors.Count; i++) { var collector = additionalContextdataCollectors[i]; // if collector has no filter then it should be used. if (collector.Filter == null) { de.AdditionalContextData.AddOrUpdateRange(collector.CollectData()); de.PinAdditionalContextDataIfNeeded(); break; } if (collector.Filter.Evaluate(de, this.Name)) { de.AdditionalContextData.AddOrUpdateRange(collector.CollectData()); de.PinAdditionalContextDataIfNeeded(); break; } } } //# WRITE TO SINKS if (mustWaitForWriteSinks.Length > 0) { if (mustWaitForWriteSinks.Length == 1) { var sink = mustWaitForWriteSinks.Single(); sink.Write(de); } else { ParallelExtensions.ForEach(mustWaitForWriteSinks, (sink) => { sink.Write(de); }); } } // then write to all fire-and-forget sinks if (fireAndForgetSinks.Length > 0) ParallelExtensions.ForEachNoWait( fireAndForgetSinks, (sink) => { if (sink.Filter.Evaluate(de, Name)) sink.Write(de); }); } catch (Exception ex) { InternalTrace.Error(ex, "Failed to log diagnostic event."); } }
public void Configure(DiagnosticsConfiguration config) { config.LogConfigCache = new ConfigurationCache(); config.SinkDefinitions.RefreshCache(); foreach (var sink in config.SinkDefinitions) sink.Initialize(); config.Sinks.RefreshCache(); //# get log levels enabled states var de = new DiagnosticEvent(); de.EvaluateAndPinAllDataIfNeeded(); de.Severity = SeverityLevels.Critical; config.LogConfigCache.ShouldProcessCriticals = MeetsFiltersCriteria(de, Name, config); de.Severity = SeverityLevels.Error; config.LogConfigCache.ShouldProcessErrors = MeetsFiltersCriteria(de, Name, config); de.Severity = SeverityLevels.Warning; config.LogConfigCache.ShouldProcessWarnings = MeetsFiltersCriteria(de, Name, config); de.Severity = SeverityLevels.Information; config.LogConfigCache.ShouldProcessInformation = MeetsFiltersCriteria(de, Name, config); de.Severity = SeverityLevels.Verbose; config.LogConfigCache.ShouldProcessVerbose = MeetsFiltersCriteria(de, Name, config); //# get raw messages enabled states de.Severity = SeverityLevels.Maximum; de.HasRawMessage = true; config.LogConfigCache.ShouldProcessRawMessages = MeetsFiltersCriteria(de, Name, config); //# replace current config with new config //NOTE: we are setting some values on newCache, make sure that there's a memory barrier in place Thread.MemoryBarrier(); Config = config; }
public DiagnosticsConfiguration GetConfiguration() { // make a copy of reference to current configuration // to make sure that any changes (which would replace Config) // will not be applied to this method before it exits var config_ref = Config; if (config_ref == null) return new DiagnosticsConfiguration(); var config = new DiagnosticsConfiguration(); // TODO: all should be cloned, not copied // TODO: remember that some objects store references to other objects, those should be preserved (reassignment //# Sinks config.SinkDefinitions = new SinkCollection(config_ref.SinkDefinitions.ToArray()); config.Sinks = config_ref.Sinks; //# Fiters config.FilterDefinitions = config_ref.FilterDefinitions; config.GlobalFilters = config_ref.GlobalFilters; config.Formatters = new FormatterCollection(config_ref.Formatters.ToArray()); config.SeverityLevels = new SeverityLevelCollection(config_ref.SeverityLevels.ToArray()); //# Context Data Collectors if(config_ref.GlobalContextDataCollectors != null) config.GlobalContextDataCollectors = config_ref.GlobalContextDataCollectors.Clone(); config.AdditionalContextDataCollectors = config_ref.AdditionalContextDataCollectors.Clone(); return config; }
public RequestHistoryCache(Func<CurrentRequest> request, IEnumerable<IRequestHistoryCacheFilter> filters, DiagnosticsConfiguration configuration) { _request = request; _filters = filters; _configuration = configuration; }
public bool MeetsFiltersCriteria(DiagnosticEvent diagnosticEvent, ILoggerName loggerName, DiagnosticsConfiguration config) { //# check this loger's filters for (int i = 0; i < config.GlobalFilters.Count; i++) { var filter = config.GlobalFilters[i]; bool shouldLog = filter.Evaluate(diagnosticEvent, loggerName); if (!shouldLog) return false; } //# check parent loger's filter if (Parent != null) return Parent.MeetsFiltersCriteria(diagnosticEvent, loggerName, config); return true; }
public RequestHistoryCache(IEnumerable<IRequestHistoryCacheFilter> filters, DiagnosticsConfiguration configuration) { _filters = filters; _configuration = configuration; }
/// <summary> /// Initializes a new instance of the <see cref="NancyEngine"/> class. /// </summary> /// <param name="dispatcher">An <see cref="IRouteResolver"/> instance that will be used to resolve a route, from the modules, that matches the incoming <see cref="Request"/>.</param> /// <param name="contextFactory">A factory for creating contexts</param> /// <param name="statusCodeHandlers">Error handlers</param> /// <param name="requestTracing">The request tracing instance.</param> /// <param name="diagnosticsConfiguration"></param> /// <param name="staticContentProvider">The provider to use for serving static content</param> public NancyEngine(IRequestDispatcher dispatcher, INancyContextFactory contextFactory, IEnumerable <IStatusCodeHandler> statusCodeHandlers, IRequestTracing requestTracing, DiagnosticsConfiguration diagnosticsConfiguration, IStaticContentProvider staticContentProvider) { if (dispatcher == null) { throw new ArgumentNullException("dispatcher", "The resolver parameter cannot be null."); } if (contextFactory == null) { throw new ArgumentNullException("contextFactory"); } if (statusCodeHandlers == null) { throw new ArgumentNullException("statusCodeHandlers"); } this.dispatcher = dispatcher; this.contextFactory = contextFactory; this.statusCodeHandlers = statusCodeHandlers; this.requestTracing = requestTracing; this.diagnosticsConfiguration = diagnosticsConfiguration; this.staticContentProvider = staticContentProvider; }
/// <summary> /// Get the syslog writer. /// </summary> /// <returns>The syslog writer.</returns> public static IEventLogWriter GetSyslogEventLogWriter() { DiagnosticsConfiguration diagnosticsConfiguration = ConfigurationSettings.GetDiagnosticsConfigurationSection(); EventLogSyslogSettings syslogSettings = diagnosticsConfiguration?.SyslogSettings; if (syslogSettings == null || !syslogSettings.IsEnabled || string.IsNullOrEmpty(syslogSettings.HostName) || syslogSettings.Port <= 0) { return(null); } int enterpriseId = 0; string applicationName = string.Empty; SyslogConfiguration syslogConfiguration = ConfigurationSettings.GetSyslogConfigurationSection(); if (syslogConfiguration?.SyslogApplicationSettings != null) { enterpriseId = syslogConfiguration.SyslogApplicationSettings.EnterpriseId; applicationName = syslogConfiguration.SyslogApplicationSettings.ApplicationName; } // Fallback if (enterpriseId == 0) { enterpriseId = SyslogReadiNowConstants.EnterpriseId; } if (string.IsNullOrEmpty(applicationName)) { applicationName = SyslogReadiNowConstants.ApplicationName; } string databaseName = string.Empty; string databaseServer = string.Empty; var databaseConfiguration = ConfigurationSettings.GetDatabaseConfigurationSection(); if (databaseConfiguration?.ConnectionSettings != null) { databaseName = databaseConfiguration.ConnectionSettings.Database; databaseServer = databaseConfiguration.ConnectionSettings.Server; } IStreamProvider tcpStreamProvider = new TcpStreamProvider(syslogSettings.HostName, syslogSettings.Port, true, syslogSettings.IsSecure, syslogSettings.IgnoreSslErrors); ISyslogMessageSerializer syslogMsgSerializer = new SyslogMessageSerializer(); ISyslogMessageWriter streamWriter = new SyslogStreamWriter(tcpStreamProvider, syslogMsgSerializer); ISyslogMessageWriter queueingMessageWriter = new SyslogQueueingMessageWriter(streamWriter, 0); return(new EventLogSyslogWriter(queueingMessageWriter) { EnterpriseId = enterpriseId, ApplicationName = applicationName, SoftwareVersion = SystemInfo.PlatformVersion, ErrorEnabled = syslogSettings.ErrorEnabled, WarningEnabled = syslogSettings.WarningEnabled, InformationEnabled = syslogSettings.InformationEnabled, TraceEnabled = syslogSettings.TraceEnabled, InstallFolder = SystemInfo.InstallFolder, DatabaseName = databaseName, DatabaseServer = databaseServer }); }
public RequestHistoryCache(IEnumerable <IRequestHistoryCacheFilter> filters, DiagnosticsConfiguration configuration) { _filters = filters; _configuration = configuration; }
private static void RefreshingConfiguration(object sender, EventArgs e) => DiagnosticsConfiguration.Refresh();