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