/// <summary>
/// Log to the internal (NLog) logger the information about the <see cref="Target"/> and <see
/// cref="LoggingRule"/> associated with this <see cref="LoggingConfiguration"/> instance.
/// </summary>
/// <remarks>
/// The information are only recorded in the internal logger if Debug level is enabled, otherwise nothing is
/// recorded.
/// </remarks>
internal void Dump()
{
if (!InternalLogger.IsDebugEnabled)
{
return;
}
InternalLogger.Debug("--- NLog configuration dump ---");
InternalLogger.Debug("Targets:");
var targetList = _targets.Values.ToList();
foreach (Target target in targetList)
{
InternalLogger.Debug("{0}", target);
}
InternalLogger.Debug("Rules:");
var loggingRules = LoggingRules.ToList();
foreach (LoggingRule rule in loggingRules)
{
InternalLogger.Debug("{0}", rule);
}
InternalLogger.Debug("--- End of NLog configuration dump ---");
}
/// <summary>
/// Removes the specified named logging rule.
/// </summary>
/// <param name="ruleName">The name of the logging rule to be removed.</param>
/// <returns>Found one or more logging rule to remove, or <see langword="false"/> when not found.</returns>
public bool RemoveRuleByName(string ruleName)
{
if (ruleName == null)
{
return(false);
}
HashSet <LoggingRule> removedRules = new HashSet <LoggingRule>();
var loggingRules = GetLoggingRulesThreadSafe();
foreach (var loggingRule in loggingRules)
{
if (string.Equals(loggingRule.RuleName, ruleName, StringComparison.OrdinalIgnoreCase))
{
removedRules.Add(loggingRule);
}
}
if (removedRules.Count > 0)
{
lock (LoggingRules)
{
for (int i = LoggingRules.Count - 1; i >= 0; i--)
{
if (removedRules.Contains(LoggingRules[i]))
{
LoggingRules.RemoveAt(i);
}
}
}
}
return(removedRules.Count > 0);
}
/// <summary>
/// Validates the configuration.
/// </summary>
internal void ValidateConfig()
{
var roots = new List <object>();
var loggingRules = LoggingRules.ToList();
foreach (LoggingRule rule in loggingRules)
{
roots.Add(rule);
}
var targetList = _targets.Values.ToList();
foreach (Target target in targetList)
{
roots.Add(target);
}
_configItems = ObjectGraphScanner.FindReachableObjects <object>(true, roots.ToArray());
// initialize all config items starting from most nested first
// so that whenever the container is initialized its children have already been
InternalLogger.Info("Found {0} configuration items", _configItems.Count);
foreach (object o in _configItems)
{
PropertyHelper.CheckRequiredParameters(o);
}
}
/// <summary>
/// Add a rule for alle loglevels.
/// </summary>
/// <param name="target">Target to be written to when the rule matches.</param>
/// <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
public void AddRuleForAllLevels(Target target, string loggerNamePattern = "*")
{
var loggingRule = new LoggingRule(loggerNamePattern, target);
loggingRule.EnableLoggingForLevels(LogLevel.MinLevel, LogLevel.MaxLevel);
LoggingRules.Add(loggingRule);
}
/// <summary>
/// Add a rule for one loglevel.
/// </summary>
/// <param name="level">log level needed to trigger this rule. </param>
/// <param name="target">Target to be written to when the rule matches.</param>
/// <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
public void AddRuleForOneLevel(LogLevel level, Target target, string loggerNamePattern = "*")
{
var loggingRule = new LoggingRule(loggerNamePattern, target);
loggingRule.EnableLoggingForLevel(level);
LoggingRules.Add(loggingRule);
}
public DefaultNLogConfiguration()
{
var consoleTarget = new ColoredConsoleTarget {
Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}"
};
var rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget);
AddTarget("_default_console", consoleTarget);
LoggingRules.Add(rule1);
}
/// <summary>
/// Create a host and initialize the environment.
/// </summary>
/// <param name="builder"></param>
public void Init(HostEnvironment.Builder builder)
{
var hostEnvironment = builder.Create();
// setup any logging rules
LoggingRules.SetRules(LoggingRulesList.Create(false, hostEnvironment.LoggingRules));
// create the main build host
BuildHost.CreateHost(hostEnvironment);
// now hang on, we need to do the appropriate registration and setup
Logging.Set(hostEnvironment.Logger);
// set the default collection comparer for children
PrimitiveCollectionComparer.SetDefault(hostEnvironment.DefaultCollectionComparer);
}
/// <summary>
/// Flushes any pending log messages on all appenders.
/// </summary>
/// <param name="asyncContinuation">The asynchronous continuation.</param>
internal void FlushAllTargets(AsyncContinuation asyncContinuation)
{
InternalLogger.Trace("Flushing all targets...");
var uniqueTargets = new List <Target>();
var loggingRules = LoggingRules.ToList();
foreach (var rule in loggingRules)
{
var targetList = rule.Targets.ToList();
foreach (var target in targetList)
{
if (!uniqueTargets.Contains(target))
{
uniqueTargets.Add(target);
}
}
}
AsyncHelpers.ForEachItemInParallel(uniqueTargets, asyncContinuation, (target, cont) => target.Flush(cont));
}
public TestLoggingConfiguration()
{
Target = new TestTarget();
LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, Target));
}
/// <summary>
/// Add a rule with min- and maxLevel.
/// </summary>
/// <param name="minLevel">Minimum log level needed to trigger this rule.</param>
/// <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
/// <param name="target">Target to be written to when the rule matches.</param>
/// <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
public void AddRule(LogLevel minLevel, LogLevel maxLevel, Target target, string loggerNamePattern = "*")
{
LoggingRules.Add(new LoggingRule(loggerNamePattern, minLevel, maxLevel, target));
}
