/// <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 static void EnableDebugConsoleOutput() { if (IsDebugConsoleOutputEnabled) { return; } LoggingConfiguration config = LogManager.Configuration; ConsoleTarget consoleTarget = new ConsoleTarget() { Name = "consoleDebugOutput" }; LoggingRule consoleRule = new LoggingRule("*", consoleTarget); consoleRule.EnableLoggingForLevel(LogLevel.Trace); consoleRule.EnableLoggingForLevel(LogLevel.Debug); config.AddTarget(consoleTarget); config.LoggingRules.Add(consoleRule); IsDebugConsoleOutputEnabled = true; }
/// <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 = "*") { if (target == null) { throw new ArgumentNullException(nameof(target)); } var loggingRule = new LoggingRule(loggerNamePattern, target); loggingRule.EnableLoggingForLevel(level); AddLoggingRulesThreadSafe(loggingRule); }
private static void ConfigureLogging(bool enableVerboseLogging) { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); consoleTarget.Layout = "> ${message}"; var rule1 = new LoggingRule("*", LogLevel.Info, consoleTarget); if (enableVerboseLogging) { rule1.EnableLoggingForLevel(LogLevel.Trace); rule1.EnableLoggingForLevel(LogLevel.Debug); } config.LoggingRules.Add(rule1); LogManager.Configuration = config; }
private static void ChangeRuleMinLevel(LoggingRule rule, LogLevel minLevel) { /* * Based on how the LoggingLevel initializes its logging levels when given a minLevel, * but because LogLevel.MinLevel and LogLevel.MaxLevel are not publically accessible, * their current values are hardcoded. TODO: This is fragile! */ for (var i = LogLevel.Trace.Ordinal; i < minLevel.Ordinal; i++) { rule.DisableLoggingForLevel(LogLevel.FromOrdinal(i)); } for (var i = minLevel.Ordinal; i <= LogLevel.Fatal.Ordinal; i++) { rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } LogManager.ReconfigExistingLoggers(); }
/// <summary> /// Parse {Logger} xml element /// </summary> /// <param name="loggerElement"></param> /// <param name="rulesCollection">Rules are added to this parameter.</param> private void ParseLoggerElement(NLogXmlElement loggerElement, IList <LoggingRule> rulesCollection) { loggerElement.AssertName("logger"); var namePattern = loggerElement.GetOptionalAttribute("name", "*"); var enabled = loggerElement.GetOptionalBooleanAttribute("enabled", true); if (!enabled) { InternalLogger.Debug("The logger named '{0}' are disabled"); return; } var rule = new LoggingRule(); string appendTo = loggerElement.GetOptionalAttribute("appendTo", null); if (appendTo == null) { appendTo = loggerElement.GetOptionalAttribute("writeTo", null); } rule.LoggerNamePattern = namePattern; if (appendTo != null) { foreach (string t in appendTo.Split(',')) { string targetName = t.Trim(); Target target = FindTargetByName(targetName); if (target != null) { rule.Targets.Add(target); } else { throw new NLogConfigurationException("Target " + targetName + " not found."); } } } rule.Final = loggerElement.GetOptionalBooleanAttribute("final", false); string levelString; if (loggerElement.AttributeValues.TryGetValue("level", out levelString)) { LogLevel level = LogLevel.FromString(levelString); rule.EnableLoggingForLevel(level); } else if (loggerElement.AttributeValues.TryGetValue("levels", out levelString)) { levelString = CleanSpaces(levelString); string[] tokens = levelString.Split(','); foreach (string token in tokens) { if (!string.IsNullOrEmpty(token)) { LogLevel level = LogLevel.FromString(token); rule.EnableLoggingForLevel(level); } } } else { int minLevel = 0; int maxLevel = LogLevel.MaxLevel.Ordinal; string minLevelString; string maxLevelString; if (loggerElement.AttributeValues.TryGetValue("minLevel", out minLevelString)) { minLevel = LogLevel.FromString(minLevelString).Ordinal; } if (loggerElement.AttributeValues.TryGetValue("maxLevel", out maxLevelString)) { maxLevel = LogLevel.FromString(maxLevelString).Ordinal; } for (int i = minLevel; i <= maxLevel; ++i) { rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } } var children = loggerElement.Children.ToList(); foreach (var child in children) { switch (child.LocalName.ToUpper(CultureInfo.InvariantCulture)) { case "FILTERS": this.ParseFilters(rule, child); break; case "LOGGER": this.ParseLoggerElement(child, rule.ChildRules); break; } } rulesCollection.Add(rule); }
private void ConfigureRulesFromElement(LoggingConfiguration config, LoggingRuleCollection rules, XmlElement element) { if (element == null) { return; } foreach (XmlElement el in PropertyHelper.GetChildElements(element, "logger")) { XmlElement ruleElement = el; LoggingRule rule = new LoggingRule(); string namePattern = GetCaseInsensitiveAttribute(ruleElement, "name"); if (namePattern == null) { namePattern = "*"; } string appendTo = GetCaseInsensitiveAttribute(ruleElement, "appendTo"); if (appendTo == null) { appendTo = GetCaseInsensitiveAttribute(ruleElement, "writeTo"); } rule.LoggerNamePattern = namePattern; if (appendTo != null) { foreach (string t in appendTo.Split(',')) { string targetName = t.Trim(); Target target = config.FindTargetByName(targetName); if (target != null) { rule.Targets.Add(target); } else { throw new NLogConfigurationException("Target " + targetName + " not found."); } } } rule.Final = false; if (HasCaseInsensitiveAttribute(ruleElement, "final")) { rule.Final = true; } if (HasCaseInsensitiveAttribute(ruleElement, "level")) { LogLevel level = LogLevel.FromString(GetCaseInsensitiveAttribute(ruleElement, "level")); rule.EnableLoggingForLevel(level); } else if (HasCaseInsensitiveAttribute(ruleElement, "levels")) { string levelsString = GetCaseInsensitiveAttribute(ruleElement, "levels"); levelsString = CleanWhitespace(levelsString); string[] tokens = levelsString.Split(','); foreach (string s in tokens) { if (s != "") { LogLevel level = LogLevel.FromString(s); rule.EnableLoggingForLevel(level); } } } else { int minLevel = 0; int maxLevel = LogLevel.MaxLevel.Ordinal; if (HasCaseInsensitiveAttribute(ruleElement, "minlevel")) { minLevel = LogLevel.FromString(GetCaseInsensitiveAttribute(ruleElement, "minlevel")).Ordinal; } if (HasCaseInsensitiveAttribute(ruleElement, "maxlevel")) { maxLevel = LogLevel.FromString(GetCaseInsensitiveAttribute(ruleElement, "maxlevel")).Ordinal; } for (int i = minLevel; i <= maxLevel; ++i) { rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } } foreach (XmlElement el2 in PropertyHelper.GetChildElements(ruleElement, "filters")) { ConfigureRuleFiltersFromXmlElement(rule, el2); } ConfigureRulesFromElement(config, rule.ChildRules, ruleElement); rules.Add(rule); } }
/// <summary> /// Parse {Logger} xml element /// </summary> /// <param name="loggerElement"></param> /// <param name="rulesCollection">Rules are added to this parameter.</param> private void ParseLoggerElement(NLogXmlElement loggerElement, IList<LoggingRule> rulesCollection) { loggerElement.AssertName("logger"); var namePattern = loggerElement.GetOptionalAttribute("name", "*"); var enabled = loggerElement.GetOptionalBooleanAttribute("enabled", true); if (!enabled) { InternalLogger.Debug("The logger named '{0}' are disabled"); return; } var rule = new LoggingRule(); string appendTo = loggerElement.GetOptionalAttribute("appendTo", null); if (appendTo == null) { appendTo = loggerElement.GetOptionalAttribute("writeTo", null); } rule.LoggerNamePattern = namePattern; if (appendTo != null) { foreach (string t in appendTo.Split(',')) { string targetName = t.Trim(); Target target = FindTargetByName(targetName); if (target != null) { rule.Targets.Add(target); } else { throw new NLogConfigurationException("Target " + targetName + " not found."); } } } rule.Final = loggerElement.GetOptionalBooleanAttribute("final", false); string levelString; if (loggerElement.AttributeValues.TryGetValue("level", out levelString)) { LogLevel level = LogLevel.FromString(levelString); rule.EnableLoggingForLevel(level); } else if (loggerElement.AttributeValues.TryGetValue("levels", out levelString)) { levelString = CleanSpaces(levelString); string[] tokens = levelString.Split(','); foreach (string s in tokens) { if (!string.IsNullOrEmpty(s)) { LogLevel level = LogLevel.FromString(s); rule.EnableLoggingForLevel(level); } } } else { int minLevel = 0; int maxLevel = LogLevel.MaxLevel.Ordinal; string minLevelString; string maxLevelString; if (loggerElement.AttributeValues.TryGetValue("minLevel", out minLevelString)) { minLevel = LogLevel.FromString(minLevelString).Ordinal; } if (loggerElement.AttributeValues.TryGetValue("maxLevel", out maxLevelString)) { maxLevel = LogLevel.FromString(maxLevelString).Ordinal; } for (int i = minLevel; i <= maxLevel; ++i) { rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } } foreach (var child in loggerElement.Children) { switch (child.LocalName.ToUpper(CultureInfo.InvariantCulture)) { case "FILTERS": this.ParseFilters(rule, child); break; case "LOGGER": this.ParseLoggerElement(child, rule.ChildRules); break; } } rulesCollection.Add(rule); }
private void ParseLoggerElement(XmlReader reader, ICollection<LoggingRule> rulesCollection) { LoggingRule rule = new LoggingRule(); string namePattern = this.GetCaseInsensitiveAttribute(reader, "name", "*"); string appendTo = this.GetCaseInsensitiveAttribute(reader, "appendTo", null); if (appendTo == null) { appendTo = this.GetCaseInsensitiveAttribute(reader, "writeTo", null); } rule.LoggerNamePattern = namePattern; if (appendTo != null) { foreach (string t in appendTo.Split(',')) { string targetName = t.Trim(); Target target = FindTargetByName(targetName); if (target != null) { rule.Targets.Add(target); } else { throw new NLogConfigurationException("Target " + targetName + " not found."); } } } rule.Final = false; if (this.GetCaseInsensitiveAttribute(reader, "final", "false") == "true") { rule.Final = true; } string levelString; if (this.TryGetCaseInsensitiveAttribute(reader, "level", out levelString)) { LogLevel level = LogLevel.FromString(levelString); rule.EnableLoggingForLevel(level); } else if (this.TryGetCaseInsensitiveAttribute(reader, "levels", out levelString)) { levelString = this.CleanWhitespace(levelString); string[] tokens = levelString.Split(','); foreach (string s in tokens) { if (!string.IsNullOrEmpty(s)) { LogLevel level = LogLevel.FromString(s); rule.EnableLoggingForLevel(level); } } } else { int minLevel = 0; int maxLevel = LogLevel.MaxLevel.Ordinal; string minLevelString; string maxLevelString; if (this.TryGetCaseInsensitiveAttribute(reader, "minLevel", out minLevelString)) { minLevel = LogLevel.FromString(minLevelString).Ordinal; } if (this.TryGetCaseInsensitiveAttribute(reader, "maxLevel", out maxLevelString)) { maxLevel = LogLevel.FromString(maxLevelString).Ordinal; } for (int i = minLevel; i <= maxLevel; ++i) { rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } } if (!reader.IsEmptyElement) { while (this.MoveToNextElement(reader)) { switch (reader.LocalName.ToLower(CultureInfo.InvariantCulture)) { case "filters": this.ParseFilters(rule, reader); break; case "logger": this.ParseLoggerElement(reader, rule.ChildRules); break; default: reader.Skip(); break; } } } rulesCollection.Add(rule); }
private void SetLogLevelForRule(LoggingRule rule, LogLevel activeLogLevel) { // Reset all log levels to off for (int i = MinLogLevel; i <= MaxLogLevel; i++) { rule.DisableLoggingForLevel(LogLevel.FromOrdinal(i)); } // Enable the active log level and all levels numerically higher for (int i = activeLogLevel.GetHashCode(); i <= MaxLogLevel; i++) { rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } InternalLogger.Debug("*** Setting active log level for " + _logger.Name + " to " + activeLogLevel.Name); }
public static void EnableWarningLogging() { if (IsWarningLoggingEnabled) { return; } LoggingConfiguration config = LogManager.Configuration; FileTarget warningTarget = new FileTarget() { Name = "fileWarnings", Layout = "${longdate} | ${level:uppercase=true} | ${logger} | ${message}", FileName = BaseLogDirectory + @"\Warning\warning.log", ArchiveFileName = BaseLogDirectory + @"\MobiBot\Warning\warning.{###}.txt", ArchiveEvery = FileArchivePeriod.Day, ArchiveNumbering = ArchiveNumberingMode.Rolling, MaxArchiveFiles = 30, NetworkWrites = true, KeepFileOpen = true }; LoggingRule warningRule = new LoggingRule("*", warningTarget); warningRule.EnableLoggingForLevel(LogLevel.Warn); config.AddTarget(warningTarget); config.LoggingRules.Add(warningRule); IsWarningLoggingEnabled = true; }
private void ApplyLogLevel(LoggingRule rule, IList<LogLevel> levels) { foreach (var level in rule.Levels) rule.DisableLoggingForLevel(level); foreach (var level in levels) rule.EnableLoggingForLevel(level); }
void MvcApplication_BeginRequest(object sender, EventArgs e) { try { if (HttpContext.Current.Request.QueryString["vm"] != null && Convert.ToInt32(HttpContext.Current.Request.QueryString["vm"]) == 10) { MemoryTarget _logTarget = null; _loggerName = Guid.NewGuid().ToString().Replace("-", string.Empty); HttpContext.Current.Items.Add("LoggerName", _loggerName); _logTarget = new MemoryTarget(); _logTarget.Name = _loggerName.ToString(); LoggingRule rule = new LoggingRule(_loggerName, _logTarget); rule.EnableLoggingForLevel(LogLevel.Debug); rule.EnableLoggingForLevel(LogLevel.Trace); rule.EnableLoggingForLevel(LogLevel.Info); rule.EnableLoggingForLevel(LogLevel.Warn); rule.EnableLoggingForLevel(LogLevel.Error); rule.EnableLoggingForLevel(LogLevel.Fatal); LogManager.Configuration.LoggingRules.Add(rule); LogManager.Configuration.Reload(); } } catch (Exception ex) { LogEventInfo info = new LogEventInfo(LogLevel.Error, ECMSSettings.DEFAULT_LOGGER, ex.ToString()); ECMSLogger.Instance.Log(info); } }