static void Main(string[] args) { //Target.Register<DevToolTarget>("DevTool"); NullTarget blackhole = new NullTarget(); LoggingConfiguration conf = LogManager.Configuration; // FIXME Evite un bouclage des logs internes avec leurs envoies. Boucle infini ... conf.AddRuleForAllLevels(blackhole, "DevToolsConnector.*", true); conf.AddRuleForAllLevels(blackhole, "DevToolsMessage.*", true); conf.AddTarget("DevTool", _targetOuput); conf.AddRuleForAllLevels(_targetOuput); LogManager.Configuration = conf; var serializer = new NewtonsoftSerializer(); var server = new DevToolServer(new DevSocketFactory(serializer)); server.Bound(); server.RegisterListener <DevIdentificationRequest>(IdentificationRequestHandler); server.RegisterListener <DevStartSendLogsRequest>(OnSetLogConfig); LOGGER.Debug("Enter to stop console."); Console.ReadLine(); server.UnRegisterListener <DevIdentificationRequest>(IdentificationRequestHandler); server.UnRegisterListener <DevStartSendLogsRequest>(OnSetLogConfig); server.Close(); }
static MainControl() { var fileTarget = new FileTarget { MaxArchiveFiles = 3, ArchiveOldFileOnStartup = true, FileName = "${environment:variable=TEMP}/AudioBand.log", KeepFileOpen = true, OpenFileCacheTimeout = 30, Layout = NLog.Layouts.Layout.FromString("${longdate}|${level:uppercase=true}|${logger}|${message} ${exception:format=tostring}") }; var nullTarget = new NullTarget(); var filter = new LoggingRule("CSDeskBand.*", LogLevel.Trace, nullTarget) { Final = true }; var fileRule = new LoggingRule("*", LogLevel.Debug, fileTarget); var config = new LoggingConfiguration(); config.AddTarget("logfile", fileTarget); config.AddTarget("null", nullTarget); config.LoggingRules.Add(filter); config.LoggingRules.Add(fileRule); LogManager.Configuration = config; AppDomain.CurrentDomain.UnhandledException += (sender, args) => LogManager.GetCurrentClassLogger().Error((Exception)args.ExceptionObject); }
public static LoggingConfiguration Create() { var config = new LoggingConfiguration(); // Define targets var targetBlackHole = new NullTarget { Name = "BlackHole" }; var targetConsole = new ColoredConsoleTarget { Name = "Console", Layout = Layout.FromString("${longdate} ${pad:padding=5:inner=${level:uppercase=true}} ${message} ${exception:format=tostring}"), UseDefaultRowHighlightingRules = true, ErrorStream = false }; // Define rules var ruleMicrosoft = new LoggingRule("Microsoft.*", LogLevel.Debug, LogLevel.Info, targetBlackHole) { Final = true }; var ruleEverything = new LoggingRule("*", LogLevel.Debug, LogLevel.Fatal, targetConsole); // Register. config.AddTarget(targetBlackHole); config.AddTarget(targetConsole); config.LoggingRules.Add(ruleMicrosoft); config.LoggingRules.Add(ruleEverything); return(config); }
static void Main(string[] args) { NullTarget target = new NullTarget(); target.Layout = "${message}"; target.FormatMessage = true; NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug); Logger logger = LogManager.GetLogger("Example"); logger.Debug("log message"); }
public void OnDeserializedCalledOnDeserialization() { using (MixinConfiguration.BuildFromActive().ForClass <NullTarget> ().Clear().AddMixins(typeof(MixinWithOnInitializedAndOnDeserialized)).EnterScope()) { NullTarget instance = ObjectFactory.Create <NullTarget> (ParamList.Empty); Assert.That(Mixin.Get <MixinWithOnInitializedAndOnDeserialized> (instance).OnDeserializedCalled, Is.False); NullTarget deserializedInstance = Serializer.SerializeAndDeserialize(instance); Assert.That(Mixin.Get <MixinWithOnInitializedAndOnDeserialized> (deserializedInstance).OnDeserializedCalled, Is.True); } }
public void MixinConfigurationCanDifferAtDeserializationTime() { byte[] serializedData; using (MixinConfiguration.BuildFromActive().ForClass <NullTarget> ().Clear().AddMixins(typeof(NullMixin)).EnterScope()) { NullTarget instance = ObjectFactory.Create <NullTarget> (ParamList.Empty); Assert.That(Mixin.Get <NullMixin> (instance), Is.Not.Null); serializedData = Serializer.Serialize(instance); } var deserializedInstance = (NullTarget)Serializer.Deserialize(serializedData); Assert.That(Mixin.Get <NullMixin> (deserializedInstance), Is.Not.Null); }
private static void RegisterSentry(bool updateClient) { string dsn; if (updateClient) { dsn = RuntimeInfo.IsProduction ? "https://[email protected]/11" : "https://[email protected]/9"; } else { dsn = RuntimeInfo.IsProduction ? "https://[email protected]/8" : "https://[email protected]/10"; } Target target; try { target = new SentryTarget(dsn) { Name = "sentryTarget", Layout = "${message}" }; } catch (Exception ex) { Console.WriteLine("Failed to load dependency, may need an OS update: " + ex.ToString()); LogManager.GetLogger(nameof(NzbDroneLogger)).Debug(ex, "Failed to load dependency, may need an OS update"); // We still need the logging rules, so use a null target. target = new NullTarget(); } var loggingRule = new LoggingRule("*", updateClient ? LogLevel.Trace : LogLevel.Warn, target); LogManager.Configuration.AddTarget("sentryTarget", target); LogManager.Configuration.LoggingRules.Add(loggingRule); // Events logged to Sentry go only to Sentry. var loggingRuleSentry = new LoggingRule("Sentry", LogLevel.Debug, target) { Final = true }; LogManager.Configuration.LoggingRules.Insert(0, loggingRuleSentry); }
internal static void ConfigureLogging() { var config = Pool.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}"; var nullTarget = new NullTarget("null") { }; loggingConfig.AddTarget(nullTarget); // Suppress some Aspnet stuff loggingConfig.AddRule(level, LogLevel.Info, nullTarget, "Microsoft.AspNetCore.Mvc.Internal.*", true); loggingConfig.AddRule(level, LogLevel.Info, nullTarget, "Microsoft.AspNetCore.Mvc.Infrastructure.*", true); // Api Log if (!string.IsNullOrEmpty(config.ApiLogFile)) { var target = new FileTarget("file") { FileName = GetLogPath(config, config.ApiLogFile), FileNameKind = FilePathKind.Unknown, Layout = layout }; loggingConfig.AddTarget(target); loggingConfig.AddRule(level, LogLevel.Fatal, target, "Microsoft.AspNetCore.*", true); } 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 Pool.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; // Set default logger name logger = LogManager.GetLogger("FileLogger"); }
public static LoggingConfiguration GetNLogCOnfiguration(string apiVersion = "") { //%date %-5level [%property{ExecutingCtx}] - %message | %stacktrace{5} | [%logger ]%newline" var layout = @"${longdate:universalTime=true} ${pad:padding=5:inner=${level:uppercase=true}} [${pad:padding=5:inner=${mdlc:item=IID}}] - ${message} ${when:when=length('${exception}')>0:Inner=[BEGIN_EXCEPTION_}${exception:format=toString,Data:maxInnerExceptionLevel=10}${when:when=length('${exception}')>0:Inner=_END_EXCEPTION]} | ${event-properties:item=EventId_Id} ${ndlc:uppercase=true:separator= => } | [${callsite:fileName=true:methodName=true:cleanNamesOfAsyncContinuations=true:cleanNamesOfAnonymousDelegates=true:includeSourcePath=false}] [${logger:shortName=false}] [$END$]"; // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); var commonLayout = layout; var consoleLayout = commonLayout.Replace("[$END$]", ""); consoleTarget.Layout = consoleLayout; fileTarget.FileName = $"${{basedir}}/logs/log{apiVersion}.log"; fileTarget.Layout = commonLayout; fileTarget.ArchiveNumbering = ArchiveNumberingMode.DateAndSequence; fileTarget.ArchiveEvery = FileArchivePeriod.Day; //fileTarget.KeepFileOpen = true; fileTarget.AutoFlush = true; fileTarget.ArchiveDateFormat = "dd-MM-yyyy"; fileTarget.ArchiveOldFileOnStartup = true; fileTarget.ArchiveFileName = $"${{basedir}}/logs/log{apiVersion}{{#}}.log.zip"; fileTarget.EnableArchiveFileCompression = true; var blFileTarget = new FileTarget(); config.AddTarget("blFileTarget", blFileTarget); blFileTarget.FileName = $"${{basedir}}/logs/BL-log{apiVersion}.log"; blFileTarget.Layout = fileTarget.Layout; blFileTarget.ArchiveNumbering = ArchiveNumberingMode.DateAndSequence; blFileTarget.ArchiveEvery = FileArchivePeriod.Day; blFileTarget.AutoFlush = true; blFileTarget.ArchiveDateFormat = "dd-MM-yyyy"; blFileTarget.ArchiveOldFileOnStartup = true; blFileTarget.ArchiveFileName = $"${{basedir}}/logs/BL-log{apiVersion}{{#}}.log.zip"; blFileTarget.EnableArchiveFileCompression = true; var blackHole = new NullTarget("blackHole"); config.AddTarget("blackHole", blackHole); // Step 4. Define rules var rule1 = new LoggingRule("*", NLog.LogLevel.Trace, consoleTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", NLog.LogLevel.Trace, fileTarget); config.LoggingRules.Add(rule2); //var rulePH = new LoggingRule("PH.*", NLog.LogLevel.Debug, fileTarget); //config.LoggingRules.Add(rulePH); //var ruleMs = new LoggingRule("Microsoft.*", NLog.LogLevel.Trace, blackHole); //config.LoggingRules.Add(ruleMs); //var blRule = new LoggingRule("PH.Core3.*", NLog.LogLevel.Debug, blFileTarget); //blRule.LoggerNamePattern = "PH.Core3.Test.*"; ////config.LoggingRules.Add(blRule); return(config); }
public static void Configure(Settings settings) { NServiceBus.Logging.LogManager.Use <NLogFactory>(); if (LogManager.Configuration != null) { return; } var version = typeof(HostService).Assembly.GetName().Version; var nlogConfig = new LoggingConfiguration(); var simpleLayout = new SimpleLayout("${longdate}|${threadid}|${level}|${logger}|${message}${onexception:${newline}${exception:format=tostring}}"); var header = $@"------------------------------------------------------------- ServiceControl Monitoring Version: {version} Selected Transport: {settings.TransportType} -------------------------------------------------------------"; var fileTarget = new FileTarget { ArchiveEvery = FileArchivePeriod.Day, FileName = Path.Combine(settings.LogPath, "logfile.${shortdate}.txt"), ArchiveFileName = Path.Combine(settings.LogPath, "logfile.{#}.txt"), ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, Layout = simpleLayout, MaxArchiveFiles = 14, ArchiveAboveSize = 30 * MegaByte, Header = new SimpleLayout(header) }; var consoleTarget = new ColoredConsoleTarget { Layout = simpleLayout, UseDefaultRowHighlightingRules = true }; var nullTarget = new NullTarget(); nlogConfig.AddTarget("console", consoleTarget); nlogConfig.AddTarget("debugger", fileTarget); nlogConfig.AddTarget("null", nullTarget); //Suppress NSB license logging since this will have it's own nlogConfig.LoggingRules.Add(new LoggingRule("NServiceBus.LicenseManager", LogLevel.Info, nullTarget) { Final = true }); // Always want to see license logging regardless of default logging level nlogConfig.LoggingRules.Add(new LoggingRule("ServiceControl.Monitoring.Licensing.*", LogLevel.Info, fileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("ServiceControl.Monitoring.Licensing.*", LogLevel.Info, consoleTarget) { Final = true }); // Defaults nlogConfig.LoggingRules.Add(new LoggingRule("*", settings.LogLevel, fileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("*", settings.LogLevel < LogLevel.Info ? settings.LogLevel : LogLevel.Info, consoleTarget)); // Remove Console Logging when running as a service if (!Environment.UserInteractive) { foreach (var rule in nlogConfig.LoggingRules.Where(p => p.Targets.Contains(consoleTarget)).ToList()) { nlogConfig.LoggingRules.Remove(rule); } } LogManager.Configuration = nlogConfig; var logger = NServiceBus.Logging.LogManager.GetLogger("LoggingConfiguration"); var logEventInfo = new LogEventInfo { TimeStamp = DateTime.Now }; logger.InfoFormat("Logging to {0} with LogLevel '{1}'", fileTarget.FileName.Render(logEventInfo), settings.LogLevel.Name); }
private static bool SetupLoging(JObject settings) { var dirty = false; if (!settings.ContainsKey("LogLevel")) { settings["LogLevel"] = JToken.FromObject(LogLevel.Info); dirty = true; } if (!settings.ContainsKey("LogBlacklist")) { settings["LogBlacklist"] = JObject.FromObject(new Dictionary <string, LogLevel>() { [$"{typeof(RawInputProcessor).Namespace}.*"] = LogLevel.Trace, [$"{typeof(XInputProcessor).Namespace}.*"] = LogLevel.Trace, [$"{typeof(ShortcutViewModel).FullName}"] = LogLevel.Trace }); dirty = true; } var config = new LoggingConfiguration(); const string layout = "${longdate}|${level:uppercase=true}|${logger}|${message}${onexception:|${exception:format=ToString}}"; if (settings.TryGetValue <Dictionary <string, LogLevel> >("LogBlacklist", out var blacklist)) { var blackhole = new NullTarget(); foreach (var(filter, maxLevel) in blacklist) { config.AddRule(LogLevel.Trace, maxLevel, blackhole, filter, true); } } if (settings.TryGetValue <LogLevel>("LogLevel", out var minLevel)) { config.AddRule(minLevel, LogLevel.Fatal, new FileTarget("file") { FileName = @"${basedir}\Logs\latest.log", ArchiveFileName = @"${basedir}\Logs\log.{#}.log", ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, ArchiveAboveSize = 1048576, ArchiveDateFormat = "yyyyMMdd", ArchiveOldFileOnStartup = true, MaxArchiveFiles = 10, ConcurrentWrites = false, KeepFileOpen = true, OpenFileCacheTimeout = 30, AutoFlush = false, OpenFileFlushTimeout = 5, Layout = layout }); } if (Debugger.IsAttached) { config.AddRule(LogLevel.Debug, LogLevel.Fatal, new OutputDebugStringTarget("debug") { Layout = layout }); } LogManager.Configuration = config; return(dirty); }
private void ConfigureLogging(LoggingSettings loggingSettings) { LogManager.Use <NLogFactory>(); const long megaByte = 1073741824; if (NLog.LogManager.Configuration != null) { return; } var version = typeof(Bootstrapper).Assembly.GetName().Version; var nlogConfig = new LoggingConfiguration(); var simpleLayout = new SimpleLayout("${longdate}|${threadid}|${level}|${logger}|${message}${onexception:${newline}${exception:format=tostring}}"); var header = $@"------------------------------------------------------------- ServiceControl Version: {version} Selected Transport: {settings.TransportType} Audit Retention Period: {settings.AuditRetentionPeriod} Error Retention Period: {settings.ErrorRetentionPeriod} Forwarding Error Messages: {settings.ForwardErrorMessages} Forwarding Audit Messages: {settings.ForwardAuditMessages} Database Size: {DataSize()}bytes -------------------------------------------------------------"; var fileTarget = new FileTarget { ArchiveEvery = FileArchivePeriod.Day, FileName = Path.Combine(loggingSettings.LogPath, "logfile.${shortdate}.txt"), ArchiveFileName = Path.Combine(loggingSettings.LogPath, "logfile.{#}.txt"), ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, Layout = simpleLayout, MaxArchiveFiles = 14, ArchiveAboveSize = 30 * megaByte, Header = new SimpleLayout(header) }; var ravenFileTarget = new FileTarget { ArchiveEvery = FileArchivePeriod.Day, FileName = Path.Combine(loggingSettings.LogPath, "ravenlog.${shortdate}.txt"), ArchiveFileName = Path.Combine(loggingSettings.LogPath, "ravenlog.{#}.txt"), ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, Layout = simpleLayout, MaxArchiveFiles = 14, ArchiveAboveSize = 30 * megaByte, Header = new SimpleLayout(header) }; var consoleTarget = new ColoredConsoleTarget { Layout = simpleLayout, UseDefaultRowHighlightingRules = true }; var nullTarget = new NullTarget(); // There lines don't appear to be necessary. The rules seem to work without implicitly adding the targets?!? nlogConfig.AddTarget("console", consoleTarget); nlogConfig.AddTarget("debugger", fileTarget); nlogConfig.AddTarget("raven", ravenFileTarget); nlogConfig.AddTarget("bitbucket", nullTarget); // Only want to see raven errors nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", loggingSettings.RavenDBLogLevel, ravenFileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", LogLevel.Error, consoleTarget)); //Noise reduction - Only RavenDB errors on the console nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", LogLevel.Debug, nullTarget) { Final = true }); //Will swallow debug and above messages // Always want to see license logging regardless of default logging level nlogConfig.LoggingRules.Add(new LoggingRule("Particular.ServiceControl.Licensing.*", LogLevel.Info, fileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("Particular.ServiceControl.Licensing.*", LogLevel.Info, consoleTarget) { Final = true }); // Defaults nlogConfig.LoggingRules.Add(new LoggingRule("*", loggingSettings.LoggingLevel, fileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("*", loggingSettings.LoggingLevel < LogLevel.Info ? loggingSettings.LoggingLevel : LogLevel.Info, consoleTarget)); // Remove Console Logging when running as a service if (!Environment.UserInteractive) { foreach (var rule in nlogConfig.LoggingRules.Where(p => p.Targets.Contains(consoleTarget)).ToList()) { nlogConfig.LoggingRules.Remove(rule); } } NLog.LogManager.Configuration = nlogConfig; var logger = LogManager.GetLogger(typeof(Bootstrapper)); var logEventInfo = new LogEventInfo { TimeStamp = DateTime.Now }; logger.InfoFormat("Logging to {0} with LoggingLevel '{1}'", fileTarget.FileName.Render(logEventInfo), loggingSettings.LoggingLevel.Name); logger.InfoFormat("RavenDB logging to {0} with LoggingLevel '{1}'", ravenFileTarget.FileName.Render(logEventInfo), loggingSettings.RavenDBLogLevel.Name); }
/// <summary> /// Configures the n log. /// </summary> /// <param name="logToFile">if set to <c>true</c> [log to file].</param> /// <param name="ruleNameAndFileSet">The rule name and < file name, Logging Level >. Key is rule name; value is file name (not full path).</param> public static void ConfigureNLog(bool logToFile, Dictionary <string, Tuple <string, LoggingLevel> > ruleNameAndFileSet) { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration string format = @"${time}|${pad:padding=5:inner=${level:uppercase=true}}| ${message}"; // Step 3. Set target properties if (logToFile) { string format2 = @"${time}|${pad:padding=5:inner=${level:uppercase=true}}|${logger}| ${message}"; string fileName = "${shortdate}.log", logDir = LogDirectory; if (ruleNameAndFileSet != null && ruleNameAndFileSet.Count > 0) { var nullTarget = new NullTarget("BlackHole"); config.AddTarget("BlackHole", nullTarget); int i = 0; foreach (var item in ruleNameAndFileSet) { if (string.IsNullOrWhiteSpace(item.Key) || item.Key == "*") { continue; } if (!string.IsNullOrWhiteSpace(item.Value.Item1) && item.Value.Item1 != fileName) { var name = "file_" + (++i); var target = new FileTarget { EnableFileDelete = true, CreateDirs = true, Layout = format2, FileName = Path.Combine(logDir, item.Value.Item1), Name = name, }; config.AddTarget(name, target); var level = item.Value.Item2; config.LoggingRules.Add(new LoggingRule(item.Key, LogLevel.FromString(level.ToString()), target) { Final = true }); if (level != LoggingLevel.Trace) { config.LoggingRules.Add(new LoggingRule(item.Key, LogLevel.Trace, nullTarget) { Final = true }); } } } } var fileTarget = new FileTarget { EnableFileDelete = true, CreateDirs = true, Layout = format, FileName = Path.Combine(logDir, fileName), Name = "file", }; config.AddTarget("file", fileTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, fileTarget)); } #if DEBUG var consoleTarget = new ColoredConsoleTarget { Name = "console", Layout = format, }; config.AddTarget("console", consoleTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, consoleTarget)); var debugTarget = new DebuggerTarget { Name = "debug", Layout = format, }; config.AddTarget("debug", debugTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, debugTarget)); #endif // Step 5. Activate the configuration LogManager.Configuration = config; }
public static void ConfigureLogging(LoggingSettings loggingSettings) { LogManager.Use <NLogFactory>(); const long megaByte = 1073741824; if (NLog.LogManager.Configuration != null) { return; } var nlogConfig = new LoggingConfiguration(); var simpleLayout = new SimpleLayout("${longdate}|${threadid}|${level}|${logger}|${message}${onexception:${newline}${exception:format=tostring}}"); var fileTarget = new FileTarget { ArchiveEvery = FileArchivePeriod.Day, FileName = Path.Combine(loggingSettings.LogPath, "logfile.${shortdate}.txt"), ArchiveFileName = Path.Combine(loggingSettings.LogPath, "logfile.{#}.txt"), ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, Layout = simpleLayout, MaxArchiveFiles = 14, ArchiveAboveSize = 30 * megaByte }; var ravenFileTarget = new FileTarget { ArchiveEvery = FileArchivePeriod.Day, FileName = Path.Combine(loggingSettings.LogPath, "ravenlog.${shortdate}.txt"), ArchiveFileName = Path.Combine(loggingSettings.LogPath, "ravenlog.{#}.txt"), ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, Layout = simpleLayout, MaxArchiveFiles = 14, ArchiveAboveSize = 30 * megaByte }; var consoleTarget = new ColoredConsoleTarget { Layout = simpleLayout, UseDefaultRowHighlightingRules = true }; var nullTarget = new NullTarget(); // There lines don't appear to be necessary. The rules seem to work without implicitly adding the targets?!? nlogConfig.AddTarget("console", consoleTarget); nlogConfig.AddTarget("debugger", fileTarget); nlogConfig.AddTarget("raven", ravenFileTarget); nlogConfig.AddTarget("bitbucket", nullTarget); // Only want to see raven errors nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", loggingSettings.RavenDBLogLevel, ravenFileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", LogLevel.Error, consoleTarget)); //Noise reduction - Only RavenDB errors on the console nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", LogLevel.Debug, nullTarget) { Final = true }); //Will swallow debug and above messages // Always want to see license logging regardless of default logging level nlogConfig.LoggingRules.Add(new LoggingRule("Particular.ServiceControl.Licensing.*", LogLevel.Info, fileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("Particular.ServiceControl.Licensing.*", LogLevel.Info, consoleTarget) { Final = true }); // Defaults nlogConfig.LoggingRules.Add(new LoggingRule("*", loggingSettings.LoggingLevel, fileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("*", loggingSettings.LoggingLevel < LogLevel.Info ? loggingSettings.LoggingLevel : LogLevel.Info, consoleTarget)); // Remove Console Logging when running as a service if (!Environment.UserInteractive) { foreach (var rule in nlogConfig.LoggingRules.Where(p => p.Targets.Contains(consoleTarget)).ToList()) { nlogConfig.LoggingRules.Remove(rule); } } NLog.LogManager.Configuration = nlogConfig; }
private static void Configure(LoggerConfig config, IConfiguration configuration) { config = config ?? new LoggerConfig(); var jsonLoggin = configuration.GetSection("JsonLogging").Get <LoggerConfig>(); config.LogLevel = jsonLoggin.LogLevel; config.IgnoreMicrosoftLogs = jsonLoggin.IgnoreMicrosoftLogs; config.IgnoreSystemNetLogs = jsonLoggin.IgnoreSystemNetLogs; config.UseFileLogger = jsonLoggin.UseFileLogger; config.LogFilePath = jsonLoggin.LogFilePath; config.ServiceName = configuration.GetValue <string>(nameof(config.ServiceName)) ?? config.ServiceName; config.ServiceVersion = configuration.GetValue <string>(nameof(config.ServiceVersion)) ?? config.ServiceVersion; var attributes = LoggerConfig.GetDefualtLayout(); // если передавались поля для расширения лога, то добавляем их if (config.LogFields != null) { Mapper.Initialize(cfg => { cfg.CreateMap <JsonField, JsonAttribute>().ConvertUsing <JsonAttributeTypeConverter>(); cfg.CreateMap <JsonLayoutField, JsonLayout>(); }); var jsonAttributes = config.LogFields.Select(x => Mapper.Map <JsonField, JsonAttribute>(x)); attributes.AddRange(jsonAttributes); } // добавляем все поля лога в JsonLayout и записываем в конфиг var jsonLayout = new JsonLayout(); attributes.ForEach(x => jsonLayout.Attributes.Add(x)); var consoleTarget = new ConsoleTarget("all_log") { Layout = jsonLayout }; var fileTarget = new FileTarget("all_log_file") { Layout = jsonLayout, Header = "Log was created at ${longdate}${newline}", Footer = "Log was archived at ${longdate}", FileName = $"{config.LogFilePath}\\current.log", ArchiveFileName = $"{config.LogFilePath}\\archive\\archive_${{shortdate}}.{{##}}.log" }; var nullTarget = new NullTarget("blackHole"); // создаем конфиг NLog var nlogConfig = new LoggingConfiguration(); // добавление переменных для NLog nlogConfig.Variables.Add(nameof(config.ServiceName), config.ServiceName); nlogConfig.Variables.Add(nameof(config.ServiceVersion), config.ServiceVersion); if (config.IgnoreMicrosoftLogs) { nlogConfig.AddRule(NLog.LogLevel.FromOrdinal((int)config.LogLevel), NLog.LogLevel.Off, nullTarget, "Microsoft.*", true); } if (config.IgnoreSystemNetLogs) { nlogConfig.AddRule(NLog.LogLevel.FromOrdinal((int)config.LogLevel), NLog.LogLevel.Off, nullTarget, "System.Net.*", true); } nlogConfig.AddRule(NLog.LogLevel.FromOrdinal((int)config.LogLevel), NLog.LogLevel.Off, consoleTarget); if (config.UseFileLogger) { nlogConfig.AddRule(NLog.LogLevel.FromOrdinal((int)config.LogLevel), NLog.LogLevel.Off, fileTarget); } nlogConfig.AddTarget(nullTarget); nlogConfig.AddTarget(consoleTarget); if (config.UseFileLogger) { nlogConfig.AddTarget(fileTarget); } LogManager.Configuration = nlogConfig; }