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