public void MustBeRethrown_ShouldLog_exception_and_only_once(string text, Type exceptionType, bool logFirst, string levelText) { using (new InternalLoggerScope()) { var level = LogLevel.FromString(levelText); InternalLogger.LogLevel = LogLevel.Trace; InternalLogger.LogToConsole = true; InternalLogger.IncludeTimestamp = false; var ex1 = CreateException(exceptionType); //exception should be once const string prefix = " Exception: "; string expected = levelText + " " + text + prefix + ex1 + Environment.NewLine; StringWriter consoleOutWriter = new StringWriter() { NewLine = Environment.NewLine }; // Redirect the console output to a StringWriter. Console.SetOut(consoleOutWriter); // Named (based on LogLevel) public methods. if (logFirst) { InternalLogger.Log(ex1, level, text); } ex1.MustBeRethrown(); consoleOutWriter.Flush(); var actual = consoleOutWriter.ToString(); Assert.Equal(expected, actual); } }
public void AsyncTaskTarget_TestRetryException() { ILogger logger = LogManager.GetCurrentClassLogger(); var asyncTarget = new AsyncTaskTestTarget { Layout = "${level}", RetryDelayMilliseconds = 10, RetryCount = 3 }; SimpleConfigurator.ConfigureForTargetLogging(asyncTarget, LogLevel.Trace); foreach (var logLevel in LogLevel.AllLoggingLevels) { logger.Log(logLevel, logLevel == LogLevel.Debug ? "EXCEPTION" : logLevel.Name.ToUpperInvariant()); } Thread.Sleep(75); Assert.True(asyncTarget.Logs.Count != 0); LogManager.Flush(); Assert.Equal(LogLevel.MaxLevel.Ordinal, asyncTarget.Logs.Count); Assert.Equal(LogLevel.MaxLevel.Ordinal + 4, asyncTarget.WriteTasks); int ordinal = 0; while (asyncTarget.Logs.Count > 0) { string logEventMessage = asyncTarget.Logs.Dequeue(); var logLevel = LogLevel.FromString(logEventMessage); Assert.NotEqual(LogLevel.Debug, logLevel); Assert.Equal(ordinal++, logLevel.Ordinal); if (ordinal == LogLevel.Debug.Ordinal) { ++ordinal; } } LogManager.Configuration = null; }
private static LogLevel GetSetting(string configName, string envName, LogLevel defaultValue) { string value = GetSettingString(configName, envName); if (value == null) { return(defaultValue); } try { return(LogLevel.FromString(value)); } catch (Exception exception) { if (exception.MustBeRethrown()) { throw; } return(defaultValue); } }
public override async Task <Message> HandleMessage(Message msg) { MessageContext context = new MessageContext(msg, this); string dsFrom = await From.SelectStringAsync(context); string dsLevel = await Level.SelectStringAsync(context); LogLevel _level = LogLevel.FromString(dsLevel); string dsLogger = null; if (Logger != null) { dsLogger = await Logger.SelectStringAsync(context); } NLog.Logger _logger = dsLogger != null ? LogManager.GetLogger(dsLogger) : LogManager.GetCurrentClassLogger(); _logger.Log(_level, dsFrom); return(msg); }
static void Main(string[] args) { Settings Settings = Settings.Read(); //Log config var config = new LoggingConfiguration(); LogLevel logLevel = LogLevel.FromString(Settings.Log.Lvl); config.AddTarget(Settings.Log.Rule.GetRule(logLevel).Targets.First()); config.LoggingRules.Add(Settings.Log.Rule.GetRule(logLevel)); LogManager.Configuration = config; ServerHost host = new ServerHost(); host.Start(Settings); Console.WriteLine("Сервис запущен; Нажмите любую кнопку чтобы завершить..."); Console.ReadLine(); host.Stop(); Console.WriteLine("Сервис остановлен"); }
private static void InitLog(bool console) { var config = new LoggingConfiguration(); var debuggerTarget = new DebuggerTarget(); config.AddTarget("debugger", debuggerTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, debuggerTarget)); if (console) { var consoleTarget = new ColoredConsoleTarget(); consoleTarget.Layout = "${message}"; config.AddTarget("console", consoleTarget); #if DEBUG var level = LogLevel.Trace; #else var level = LogLevel.Info; #endif config.LoggingRules.Add(new LoggingRule("*", level, consoleTarget)); } if (instance.Log.Enabled) { var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); fileTarget.FileName = Path.Combine(Util.Normalize(instance.Log.Path), "${shortdate}.log"); // fileTarget.Layout = "${message}"; config.LoggingRules.Add(new LoggingRule("*", LogLevel.FromString(instance.Log.Level), fileTarget)); } LogManager.Configuration = config; logger.Info("DotOPDS v{0}", build); logger.Info("Loaded configuration from {0}", FileName); }
public void ShowTest() { using (ShimsContext.Create()) { ShimLog.AllInstances.ConfiguredLogLevelGet = (a) => { return(LogLevel.FromString("Debug")); }; ShimFeedListView.AllInstances.GetFeedListIListOfRssFeed = (a, b) => { var f = new List <RssFeed>(); return(Result.Ok <IList <RssFeed> >(f)); }; ShimBaseView.AllInstances.ShowHeaderString = (a, b) => { }; ShimBaseView.AllInstances.ShowFooterString = (a, b) => { }; ShimFeedListView.AllInstances.GetPicklist = (a) => { var r = new Picklist <RssFeed>(); return(Result.Ok(r)); }; ConfigObject layout = new ConfigObject(); var controls = new List <GuiElement>(); layout.Add(new KeyValuePair <string, object>("Width", 100)); layout.Add(new KeyValuePair <string, object>("Height", 101)); layout.Add(new KeyValuePair <string, object>("Controls", controls)); var view = new FeedListView(layout); var feeds = new List <RssFeed>(); view.Show(false, feeds); Assert.AreEqual(view._mainView.Width, 100); Assert.AreEqual(view._mainView.Height, 101); } }
/// <summary> /// The method triggered when the command line arguments are parsed /// with success. /// </summary> /// <param name="options"> /// An instance of <see cref="Options" /> containing the parsed command /// line arguments. /// </param> private static void CommandLineArgumentsParsed(Options options) { // Create our StructureMap registry and... Registry registry = new Registry(); Container container = new Container(registry); string logLevelStr = options.Verbosity.ToString(); LogLevel logLevel = LogLevel.FromString(logLevelStr); // Get the default NLog configuration - i.e. the one declared // in Nlog.config. LoggingConfiguration loggingConfiguration = LogManager.Configuration; // Add a rule for each target, based on the input Verbosity level. LoggingRule loggingRule = null; foreach (Target target in loggingConfiguration.AllTargets) { loggingRule = new LoggingRule("*", logLevel, target); loggingConfiguration.LoggingRules.Add(loggingRule); } // Get an instance. IOutputFileGenerator outputFileGenerator = container.GetInstance <IOutputFileGenerator>(); executionSuccess = outputFileGenerator.CreateOutputFile( new Tuple <string, string>( options.AccessKeyId, options.SecretAccessKey), options.AwsRegion, options.PasswordEncryptionKeyFile, options.RoleArn, options.OutputFile); }
private static void InitializeLogger() { NLogUtils.CreateConfigFileIfNotExists(); SimpleLayout simpleLayout; var layout = LogManager.Configuration.Variables.TryGetValue("TextBoxLayout", out simpleLayout) ? simpleLayout.Text : "${date:format=HH\\:MM\\:ss.ffff} [${level:upperCase=true}]\t[${logger:shortName=true}] ${message}"; var minLogLevel = LogManager.Configuration.Variables.TryGetValue("MinLogLevel", out simpleLayout) ? LogLevel.FromString(simpleLayout.Text) : LogLevel.Info; var reconfigLoggers = false; var fileTarget = LogManager.Configuration.FindTargetByName <FileTarget>("file"); if (fileTarget != null && LogManager.Configuration.Variables.TryGetValue("VerboseLayout", out simpleLayout)) { simpleLayout.Text = simpleLayout.Text.Replace("${callsite", "${callsite:skipFrames=3"); fileTarget.Layout = simpleLayout; reconfigLoggers = true; } var target = new ColoredConsoleTarget { Layout = layout, Name = "console" }; LogManager.Configuration.LoggingRules.Add(new LoggingRule("*", minLogLevel, target)); LogManager.Configuration.Reload(); //important, refreshes the config if (reconfigLoggers) { LogManager.ReconfigExistingLoggers(); } }
public void Reconfigure() { var minimumLogLevel = LogLevel.FromString(_configFileProvider.LogLevel); LogLevel minimumConsoleLogLevel; if (_configFileProvider.ConsoleLogLevel.IsNotNullOrWhiteSpace()) { minimumConsoleLogLevel = LogLevel.FromString(_configFileProvider.ConsoleLogLevel); } else if (minimumLogLevel > LogLevel.Info) { minimumConsoleLogLevel = minimumLogLevel; } else { minimumConsoleLogLevel = LogLevel.Info; } var rules = LogManager.Configuration.LoggingRules; //Console SetMinimumLogLevel(rules, "consoleLogger", minimumConsoleLogLevel); //Log Files SetMinimumLogLevel(rules, "appFileInfo", minimumLogLevel <= LogLevel.Info ? LogLevel.Info : LogLevel.Off); SetMinimumLogLevel(rules, "appFileDebug", minimumLogLevel <= LogLevel.Debug ? LogLevel.Debug : LogLevel.Off); SetMinimumLogLevel(rules, "appFileTrace", minimumLogLevel <= LogLevel.Trace ? LogLevel.Trace : LogLevel.Off); SetLogRotation(); //Log Sql SqlBuilderExtensions.LogSql = _configFileProvider.LogSql; //Sentry ReconfigureSentry(); LogManager.ReconfigExistingLoggers(); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType == JsonToken.String) { var ret = LogLevel.FromString((string)reader.Value); return(ret); } else if (reader.TokenType == JsonToken.StartObject) { reader.Read(); if (reader.TokenType == JsonToken.PropertyName && String.Equals((string)reader.Value, "name", StringComparison.OrdinalIgnoreCase)) { reader.Read(); if (reader.TokenType == JsonToken.String) { string val = (string)reader.Value; reader.Read(); Debug.Assert(reader.TokenType == JsonToken.EndObject); return(LogLevel.FromString(val)); } } } return(null); }
//!!! no test coverage in this file static Diagnostics() { try { logger = LogManager.GetCurrentClassLogger(); if (LogManager.Configuration?.LoggingRules?.Any() == true) { // config file has been read, use that } else { // no config file, use default config string nlogConfigXml = ReadDefaultConfiguration(); SetDefaultConfiguration(nlogConfigXml); } string minLogLevel = Environment.GetEnvironmentVariable(MinLogLevelEnvironmentVariableName); if (!string.IsNullOrWhiteSpace(minLogLevel)) { // this will throw if invalid value LogLevel minLogLevelParsed = LogLevel.FromString(minLogLevel); LogManager.Configuration.LoggingRules.Single().SetLoggingLevels(minLogLevelParsed, LogLevel.Fatal); LogManager.ReconfigExistingLoggers(); } } catch (Exception) { // telemetry can never crash the application, swallow the exception // this probably means no logging } }
public static string WriteLogEntry(List <object> curObjects, string logMessage, LogLevelType curLevel, Exception curException, string destinationMachineName) { LogLevel nLogLevel = LogLevel.FromString(curLevel.ToString()); LogObject curLogObject = new LogObject { Message = logMessage, CurrentDataObjects = curObjects }; Guid logGUID = Guid.NewGuid(); string uniqueID = logGUID.ToString(); string xmlMessage; using (StringWriter sw = new StringWriter()) { _curSerializer.Serialize(sw, curLogObject); xmlMessage = sw.ToString(); } LogEventInfo logRecord; if (curException != null) { logRecord = new LogEventInfo(nLogLevel, null, null, xmlMessage, null, curException); } else { logRecord = new LogEventInfo(nLogLevel, null, xmlMessage); } logRecord.Properties["DestinationMachineName"] = destinationMachineName; logRecord.Properties["UniqueID"] = uniqueID; _curLogger.Log(logRecord); return(uniqueID); }
public void FromStringTest() { Assert.Same(LogLevel.FromString("trace"), LogLevel.Trace); Assert.Same(LogLevel.FromString("debug"), LogLevel.Debug); Assert.Same(LogLevel.FromString("info"), LogLevel.Info); Assert.Same(LogLevel.FromString("warn"), LogLevel.Warn); Assert.Same(LogLevel.FromString("error"), LogLevel.Error); Assert.Same(LogLevel.FromString("fatal"), LogLevel.Fatal); Assert.Same(LogLevel.FromString("off"), LogLevel.Off); Assert.Same(LogLevel.FromString("Trace"), LogLevel.Trace); Assert.Same(LogLevel.FromString("Debug"), LogLevel.Debug); Assert.Same(LogLevel.FromString("Info"), LogLevel.Info); Assert.Same(LogLevel.FromString("Warn"), LogLevel.Warn); Assert.Same(LogLevel.FromString("Error"), LogLevel.Error); Assert.Same(LogLevel.FromString("Fatal"), LogLevel.Fatal); Assert.Same(LogLevel.FromString("Off"), LogLevel.Off); Assert.Same(LogLevel.FromString("TracE"), LogLevel.Trace); Assert.Same(LogLevel.FromString("DebuG"), LogLevel.Debug); Assert.Same(LogLevel.FromString("InfO"), LogLevel.Info); Assert.Same(LogLevel.FromString("WarN"), LogLevel.Warn); Assert.Same(LogLevel.FromString("ErroR"), LogLevel.Error); Assert.Same(LogLevel.FromString("FataL"), LogLevel.Fatal); Assert.Same(LogLevel.FromString("TRACE"), LogLevel.Trace); Assert.Same(LogLevel.FromString("DEBUG"), LogLevel.Debug); Assert.Same(LogLevel.FromString("INFO"), LogLevel.Info); Assert.Same(LogLevel.FromString("WARN"), LogLevel.Warn); Assert.Same(LogLevel.FromString("ERROR"), LogLevel.Error); Assert.Same(LogLevel.FromString("FATAL"), LogLevel.Fatal); Assert.Same(LogLevel.FromString("NoNe"), LogLevel.Off); Assert.Same(LogLevel.FromString("iNformaTION"), LogLevel.Info); Assert.Same(LogLevel.FromString("WarNING"), LogLevel.Warn); }
static void InitializeLogging(string logLevel) { var loggingConfiguration = new LoggingConfiguration(); // Create our default targets var coloredConsoleTarget = new ColoredConsoleTarget(); var logFileDir = "."; Target fileTarget = CreateDefaultFileTarget(logFileDir); loggingConfiguration.AddTarget("Console", coloredConsoleTarget); loggingConfiguration.AddTarget("DailyFile", fileTarget); // The LogLevel.Trace means has to be at least Trace to show up on console loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, coloredConsoleTarget)); // LogLevel.Debug means has to be at least Debug to show up in logfile loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget)); LogManager.Configuration = loggingConfiguration; LogManager.EnableLogging(); LogManager.GlobalThreshold = LogLevel.FromString(logLevel); }
public void AsyncTaskTarget_TestAsyncException() { ILogger logger = LogManager.GetCurrentClassLogger(); var asyncTarget = new AsyncTaskTestTarget { Layout = "${level}", RetryDelayMilliseconds = 50 }; SimpleConfigurator.ConfigureForTargetLogging(asyncTarget, LogLevel.Trace); foreach (var logLevel in LogLevel.AllLoggingLevels) { logger.Log(logLevel, logLevel == LogLevel.Debug ? "ASYNCEXCEPTION" : logLevel.Name.ToUpperInvariant()); } Assert.True(asyncTarget.WaitForWriteEvent()); Assert.NotEmpty(asyncTarget.Logs); LogManager.Flush(); Assert.Equal(LogLevel.MaxLevel.Ordinal, asyncTarget.Logs.Count); int ordinal = 0; while (asyncTarget.Logs.TryDequeue(out var logEventMessage)) { var logLevel = LogLevel.FromString(logEventMessage); Assert.NotEqual(LogLevel.Debug, logLevel); Assert.Equal(ordinal++, logLevel.Ordinal); if (ordinal == LogLevel.Debug.Ordinal) { ++ordinal; } } LogManager.Configuration = null; }
private static void ConfigureLogging(IConfiguration configuration) { const string defaultMessageLayout = "${longdate} [${pad:padding=5:inner=${level:uppercase=true}}] ${processid}:${threadid} ${logger} - ${message} ${exception:format=tostring}"; var layout = configuration["Logging:Layout"] ?? defaultMessageLayout; var level = LogLevel.FromString(configuration["Logging:DefaultLevel"] ?? "Info"); var logfile = configuration["Logging:LogFile"]; var logConfig = new LoggingConfiguration(); if (!String.IsNullOrEmpty(logfile)) { var fileTarget = new FileTarget { FileName = logfile ?? "gambot.log", Layout = layout }; logConfig.AddTarget("file", fileTarget); var fileRule = new LoggingRule("*", level, fileTarget); logConfig.LoggingRules.Add(fileRule); } var consoleTarget = new ColoredConsoleTarget { Layout = layout }; logConfig.AddTarget("console", consoleTarget); var consoleRule = new LoggingRule("*", level, consoleTarget); logConfig.LoggingRules.Add(consoleRule); LogManager.GlobalThreshold = level; LogManager.Configuration = logConfig; }
private void HandleDiscordLogs(LogSeverity severity, string source, string message, Exception exception = null) { var logLevel = LogLevel.FromString(Enum.Parse(typeof(LogSeverity), severity.ToString()).ToString()); Logger.Log(logLevel, message); }
public void FromStringFailingTest() { Assert.Throws <ArgumentException>(() => LogLevel.FromString("zzz")); Assert.Throws <ArgumentNullException>(() => LogLevel.FromString(null)); }
/// <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); }
/// <summary> /// Parse {NLog} xml element. /// </summary> /// <param name="nlogElement"></param> /// <param name="filePath">path to config file.</param> /// <param name="autoReloadDefault">The default value for the autoReload option.</param> private void ParseNLogElement(NLogXmlElement nlogElement, string filePath, bool autoReloadDefault) { InternalLogger.Trace("ParseNLogElement"); nlogElement.AssertName("nlog"); if (nlogElement.GetOptionalBooleanAttribute("useInvariantCulture", false)) { this.DefaultCultureInfo = CultureInfo.InvariantCulture; } //check loglevel as first, as other properties could write (indirect) to the internal log. InternalLogger.LogLevel = LogLevel.FromString(nlogElement.GetOptionalAttribute("internalLogLevel", InternalLogger.LogLevel.Name)); #pragma warning disable 618 this.ExceptionLoggingOldStyle = nlogElement.GetOptionalBooleanAttribute("exceptionLoggingOldStyle", false); #pragma warning restore 618 bool autoReload = nlogElement.GetOptionalBooleanAttribute("autoReload", autoReloadDefault); if (filePath != null) { this.fileMustAutoReloadLookup[GetFileLookupKey(filePath)] = autoReload; } logFactory.ThrowExceptions = nlogElement.GetOptionalBooleanAttribute("throwExceptions", logFactory.ThrowExceptions); logFactory.ThrowConfigExceptions = nlogElement.GetOptionalBooleanAttribute("throwConfigExceptions", logFactory.ThrowConfigExceptions); InternalLogger.LogToConsole = nlogElement.GetOptionalBooleanAttribute("internalLogToConsole", InternalLogger.LogToConsole); InternalLogger.LogToConsoleError = nlogElement.GetOptionalBooleanAttribute("internalLogToConsoleError", InternalLogger.LogToConsoleError); InternalLogger.LogFile = nlogElement.GetOptionalAttribute("internalLogFile", InternalLogger.LogFile); #if !SILVERLIGHT && !__IOS__ && !__ANDROID__ InternalLogger.LogToTrace = nlogElement.GetOptionalBooleanAttribute("internalLogToTrace", InternalLogger.LogToTrace); #endif InternalLogger.IncludeTimestamp = nlogElement.GetOptionalBooleanAttribute("internalLogIncludeTimestamp", InternalLogger.IncludeTimestamp); logFactory.GlobalThreshold = LogLevel.FromString(nlogElement.GetOptionalAttribute("globalThreshold", logFactory.GlobalThreshold.Name)); var children = nlogElement.Children.ToList(); //first load the extensions, as the can be used in other elements (targets etc) var extensionsChilds = children.Where(child => child.LocalName.Equals("EXTENSIONS", StringComparison.InvariantCultureIgnoreCase)).ToList(); foreach (var extensionsChild in extensionsChilds) { this.ParseExtensionsElement(extensionsChild, Path.GetDirectoryName(filePath)); } //parse all other direct elements foreach (var child in children) { switch (child.LocalName.ToUpper(CultureInfo.InvariantCulture)) { case "EXTENSIONS": //already parsed break; case "INCLUDE": this.ParseIncludeElement(child, Path.GetDirectoryName(filePath), autoReloadDefault: autoReload); break; case "APPENDERS": case "TARGETS": this.ParseTargetsElement(child); break; case "VARIABLE": this.ParseVariableElement(child); break; case "RULES": this.ParseRulesElement(child, this.LoggingRules); break; case "TIME": this.ParseTimeElement(child); break; case "POOLING": this.ParsePoolingElement(child); break; default: InternalLogger.Warn("Skipping unknown node: {0}", child.LocalName); break; } } }
/// <summary> /// Log initialization. /// </summary> internal static void InitializeLog(string logFileName = null, string logLevel = null) { // default parameters initialization from config file if (String.IsNullOrEmpty(logFileName)) { logFileName = System.Configuration.ConfigurationManager.AppSettings["logFilename"]; } if (String.IsNullOrEmpty(logFileName)) { logFileName = ("${basedir}/log/" + typeof(ConsoleUtils).Namespace.Replace(".SimpleHelpers", "") + ".log"); } if (String.IsNullOrEmpty(logLevel)) { logLevel = System.Configuration.ConfigurationManager.AppSettings["logLevel"] ?? "Info"; } // check if log was initialized with same options if (_logFileName == logFileName && _logLevel == logLevel) { return; } // save current log configuration _logFileName = logFileName; _logLevel = logLevel; // try to parse loglevel LogLevel currentLogLevel; try { currentLogLevel = LogLevel.FromString(logLevel); } catch { currentLogLevel = LogLevel.Info; } // prepare log configuration var config = new NLog.Config.LoggingConfiguration(); // console output if (!Console.IsOutputRedirected) { var consoleTarget = new NLog.Targets.ColoredConsoleTarget(); consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}"; config.AddTarget("console", consoleTarget); var rule1 = new NLog.Config.LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(rule1); } // file output var fileTarget = new NLog.Targets.FileTarget(); fileTarget.FileName = logFileName; fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\""; fileTarget.ConcurrentWrites = true; fileTarget.AutoFlush = true; fileTarget.KeepFileOpen = true; fileTarget.DeleteOldFileOnStartup = false; fileTarget.ArchiveAboveSize = 2 * 1024 * 1024; // 2 Mb fileTarget.MaxArchiveFiles = 10; fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.Date; fileTarget.ArchiveDateFormat = "yyyyMMdd_HHmmss"; // set file output to be async (commented out since doesn't work on mono) // var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget); config.AddTarget("file", fileTarget); // configure log from configuration file var rule2 = new NLog.Config.LoggingRule("*", currentLogLevel, fileTarget); config.LoggingRules.Add(rule2); // set configuration options LogManager.Configuration = config; }
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); } }
private void ConfigureFromXmlElement(XmlElement configElement, string baseDirectory) { switch (GetCaseInsensitiveAttribute(configElement, "autoReload")) { case "true": AutoReload = true; break; case "false": AutoReload = false; break; } switch (GetCaseInsensitiveAttribute(configElement, "throwExceptions")) { case "true": LogManager.ThrowExceptions = true; break; case "false": LogManager.ThrowExceptions = false; break; } switch (GetCaseInsensitiveAttribute(configElement, "internalLogToConsole")) { case "true": InternalLogger.LogToConsole = true; break; case "false": InternalLogger.LogToConsole = false; break; } #if !NETCF switch (GetCaseInsensitiveAttribute(configElement, "internalLogToConsoleError")) { case "true": InternalLogger.LogToConsoleError = true; break; case "false": InternalLogger.LogToConsoleError = false; break; } #endif string s = GetCaseInsensitiveAttribute(configElement, "internalLogFile"); if (s != null) { InternalLogger.LogFile = s; } s = GetCaseInsensitiveAttribute(configElement, "internalLogLevel"); if (s != null) { InternalLogger.LogLevel = LogLevel.FromString(s); } s = GetCaseInsensitiveAttribute(configElement, "globalThreshold"); if (s != null) { LogManager.GlobalThreshold = LogLevel.FromString(s); } foreach (XmlElement el in PropertyHelper.GetChildElements(configElement)) { switch (el.LocalName.ToLower()) { case "extensions": AddExtensionsFromElement(el, baseDirectory); break; case "include": IncludeFileFromElement(el, baseDirectory); break; case "appenders": case "targets": ConfigureTargetsFromElement(el); break; case "variable": SetVariable(el); break; case "rules": ConfigureRulesFromElement(this, LoggingRules, el); break; } } }
/// <summary> /// Setup application inspector logging; 1 file per process /// </summary> /// <param name="opts"></param> /// <returns></returns> public static Logger SetupLogging(CommandOptions opts, bool onErrorConsole = false) { //prevent being called again if already set unless closed first if (Logger != null) { return(Logger); } var config = new NLog.Config.LoggingConfiguration(); if (String.IsNullOrEmpty(opts.LogFilePath)) { opts.LogFilePath = Utils.GetPath(Utils.AppPath.defaultLog); } //clean up previous for convenience in reading if (File.Exists(opts.LogFilePath)) { // Read the file and display it line by line. System.IO.StreamReader file = new System.IO.StreamReader(opts.LogFilePath); String line = file.ReadLine(); file.Close(); if (!String.IsNullOrEmpty(line)) { if (line.Contains("AppInsLog"))//prevent file other than our logs from deletion { File.Delete(opts.LogFilePath); } else { if (Utils.CLIExecutionContext && onErrorConsole) { WriteOnce.Error(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_LOG_PATH, opts.LogFilePath), true, WriteOnce.ConsoleVerbosity.Low, false); } throw new OpException(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_LOG_PATH, opts.LogFilePath)); } } } else { try { File.WriteAllText(opts.LogFilePath, "");//verify log file path is writable } catch (Exception e) { WriteOnce.SafeLog(e.Message + "\n" + e.StackTrace, NLog.LogLevel.Error); if (Utils.CLIExecutionContext && onErrorConsole) { WriteOnce.Error(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_FILE_OR_DIR, opts.LogFilePath), true, WriteOnce.ConsoleVerbosity.Low, false); } throw new OpException((MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_FILE_OR_DIR, opts.LogFilePath))); } } LogLevel log_level = LogLevel.Error;//default if (String.IsNullOrEmpty(opts.LogFileLevel)) { opts.LogFileLevel = "Error"; } try { log_level = LogLevel.FromString(opts.LogFileLevel); } catch (Exception) { if (Utils.CLIExecutionContext && onErrorConsole) { WriteOnce.Error(MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_ARG_VALUE, "-v"), true, WriteOnce.ConsoleVerbosity.Low, false); } throw new OpException((MsgHelp.FormatString(MsgHelp.ID.CMD_INVALID_ARG_VALUE, "-v"))); } using (var fileTarget = new FileTarget() { Name = "LogFile", FileName = opts.LogFilePath, Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} ${threadid} ${level:uppercase=true} - AppInsLog - ${message}", ForceMutexConcurrentWrites = true }) { config.AddTarget(fileTarget); config.LoggingRules.Add(new LoggingRule("CST.ApplicationInspector", log_level, fileTarget)); } LogFilePath = opts.LogFilePath;//preserve for console path msg LogManager.Configuration = config; Logger = LogManager.GetLogger("CST.ApplicationInspector"); return(Logger); }
/// <summary> /// Try stringed keyword to <see cref="ConditionExpression"/> /// </summary> /// <param name="keyword"></param> /// <param name="expression"></param> /// <returns>success?</returns> private bool TryPlainKeywordToExpression(string keyword, out ConditionExpression expression) { if (0 == string.Compare(keyword, "level", StringComparison.OrdinalIgnoreCase)) { { expression = new ConditionLevelExpression(); return(true); } } if (0 == string.Compare(keyword, "logger", StringComparison.OrdinalIgnoreCase)) { { expression = new ConditionLoggerNameExpression(); return(true); } } if (0 == string.Compare(keyword, "message", StringComparison.OrdinalIgnoreCase)) { { expression = new ConditionMessageExpression(); return(true); } } if (0 == string.Compare(keyword, "loglevel", StringComparison.OrdinalIgnoreCase)) { _tokenizer.Expect(ConditionTokenType.Dot); { expression = new ConditionLiteralExpression(LogLevel.FromString(_tokenizer.EatKeyword())); return(true); } } if (0 == string.Compare(keyword, "true", StringComparison.OrdinalIgnoreCase)) { { expression = new ConditionLiteralExpression(ConditionExpression.BoxedTrue); return(true); } } if (0 == string.Compare(keyword, "false", StringComparison.OrdinalIgnoreCase)) { { expression = new ConditionLiteralExpression(ConditionExpression.BoxedFalse); return(true); } } if (0 == string.Compare(keyword, "null", StringComparison.OrdinalIgnoreCase)) { { expression = new ConditionLiteralExpression(null); return(true); } } expression = null; return(false); }
private static LogLevel GetLogLevelFromConfigurationManager() { var settingValue = CloudConfigurationManager.GetSetting("LogLevel"); return(LogLevel.FromString(settingValue)); }
public static LoggingConfiguration ConfigureLogging(this IConfiguration configuration) { var loggingConfiguration = new LoggingConfiguration(); IConfiguration userLoggingConfiguration = configuration.GetSection("diagnostics:logging"); if (!userLoggingConfiguration.GetValue <bool>("enabled")) { return(loggingConfiguration); } var userLoggingTargets = userLoggingConfiguration.GetSection("targets"); ConfigureConsoleLoggingTarget(); ConfigureFilesLoggingTarget(); void ConfigureConsoleLoggingTarget() { var consoleTarget = userLoggingTargets.GetSection("console"); if (!consoleTarget.GetValue <bool>("enabled")) { return; } var nLogColoredConsoleTarget = new ColoredConsoleTarget("console") { Encoding = Encoding.UTF8, DetectConsoleAvailable = true, DetectOutputRedirected = true }; loggingConfiguration.AddRule( LogLevel.FromString(consoleTarget["levels:minimum"]), LogLevel.FromString(consoleTarget["levels:maximum"]), nLogColoredConsoleTarget ); } void ConfigureFilesLoggingTarget() { var filesTarget = userLoggingTargets.GetSection("files"); if (!filesTarget.GetValue <bool>("enabled")) { return; } var nLogFileTarget = new FileTarget { FileName = Path.Combine(filesTarget["path"], "${shortdate}.log"), CreateDirs = true, KeepFileOpen = true, Encoding = Encoding.UTF8, WriteBom = false, LineEnding = LineEndingMode.CRLF, ArchiveEvery = FileArchivePeriod.Day, ArchiveNumbering = ArchiveNumberingMode.DateAndSequence }; loggingConfiguration.AddRule( LogLevel.FromString(filesTarget["levels:minimum"]), LogLevel.FromString(filesTarget["levels:maximum"]), nLogFileTarget ); } return(loggingConfiguration); }
private static void ConfigureLogging() { var config = clusterConfig.Logging; var loggingConfig = new LoggingConfiguration(); if (config != null) { // parse level var level = !string.IsNullOrEmpty(config.Level) ? LogLevel.FromString(config.Level) : LogLevel.Info; var layout = "[${longdate}] [${level:format=FirstCharacter:uppercase=true}] [${logger:shortName=true}] ${message} ${exception:format=ToString,StackTrace}"; if (config.EnableConsoleLog) { if (config.EnableConsoleColors) { var target = new ColoredConsoleTarget("console") { Layout = layout }; target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Trace"), ConsoleOutputColor.DarkMagenta, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Debug"), ConsoleOutputColor.Gray, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Info"), ConsoleOutputColor.White, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Warn"), ConsoleOutputColor.Yellow, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Error"), ConsoleOutputColor.Red, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Fatal"), ConsoleOutputColor.DarkRed, ConsoleOutputColor.White)); loggingConfig.AddTarget(target); loggingConfig.AddRule(level, LogLevel.Fatal, target); } else { var target = new ConsoleTarget("console") { Layout = layout }; loggingConfig.AddTarget(target); loggingConfig.AddRule(level, LogLevel.Fatal, target); } } if (!string.IsNullOrEmpty(config.LogFile)) { var target = new FileTarget("file") { FileName = GetLogPath(config, config.LogFile), FileNameKind = FilePathKind.Unknown, Layout = layout }; loggingConfig.AddTarget(target); loggingConfig.AddRule(level, LogLevel.Fatal, target); } if (config.PerPoolLogFile) { foreach (var poolConfig in clusterConfig.Pools) { var target = new FileTarget(poolConfig.Id) { FileName = GetLogPath(config, poolConfig.Id + ".log"), FileNameKind = FilePathKind.Unknown, Layout = layout }; loggingConfig.AddTarget(target); loggingConfig.AddRule(level, LogLevel.Fatal, target, poolConfig.Id); } } } LogManager.Configuration = loggingConfig; logger = LogManager.GetCurrentClassLogger(); }
public Manager(string jsonConfigFile, string logLevel, string logfileDir, bool liveMonitor, CancellationToken cancelToken, bool processConfiguration = true) { LogsFileDatabase.Manager = this; StartedOn = DateTime.UtcNow; LiveMonitor = liveMonitor; var vfi = new FileInfo(jsonConfigFile); JsonConfig = vfi.FullName; LogfileDir = logfileDir; numMessages = 0; numConnections = 0; Outputs = new List <OutputSender>(); Listeners = new List <InputListener>(); var loggingConfiguration = new LoggingConfiguration(); // Create our default targets var coloredConsoleTarget = new ColoredConsoleTarget(); Target fileTarget = CreateDefaultFileTarget(logfileDir); loggingConfiguration.AddTarget("Console", coloredConsoleTarget); loggingConfiguration.AddTarget("DailyFile", fileTarget); // The LogLevel.Trace means has to be at least Trace to show up on console loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, coloredConsoleTarget)); // LogLevel.Debug means has to be at least Debug to show up in logfile loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget)); LogManager.Configuration = loggingConfiguration; LogManager.EnableLogging(); LogManager.GlobalThreshold = LogLevel.FromString(logLevel); //LogManager.GetCurrentClassLogger() // .Info("TimberWinR Version {0}", GetAssemblyByName("TimberWinR.ServiceHost").GetName().Version.ToString()); LogManager.GetCurrentClassLogger() .Info("TimberWinR Version {0}", Assembly.GetEntryAssembly().GetName().Version.ToString()); LogManager.GetCurrentClassLogger() .Info("Database Filename: {0}", LogsFileDatabase.Instance.DatabaseFileName); try { var fi = new FileInfo(jsonConfigFile); if (fi.Exists) { LogManager.GetCurrentClassLogger().Info("Initialized, Reading Configurations From File: {0}", fi.FullName); if (!fi.Exists) { throw new FileNotFoundException("Missing config file", jsonConfigFile); } LogManager.GetCurrentClassLogger().Info("Initialized, Reading Config: {0}", fi.FullName); Config = Configuration.FromFile(jsonConfigFile); } else if (Directory.Exists(jsonConfigFile)) { DirectoryInfo di = new DirectoryInfo(jsonConfigFile); LogManager.GetCurrentClassLogger().Info("Initialized, Reading Configurations From {0}", di.FullName); Config = Configuration.FromDirectory(jsonConfigFile, cancelToken, this); } } catch (JsonSerializationException jse) { LogManager.GetCurrentClassLogger().Error(jse); } catch (Exception ex) { LogManager.GetCurrentClassLogger().Error(ex); } LogManager.GetCurrentClassLogger().Info("Log Directory {0}", logfileDir); LogManager.GetCurrentClassLogger().Info("Logging Level: {0}", LogManager.GlobalThreshold); if (processConfiguration) { ProcessConfiguration(cancelToken, Config); } }