private static void InitLogging() { var s_Config = new LoggingConfiguration(); var s_ConsoleTarget = new ColoredConsoleTarget(); s_Config.AddTarget("console", s_ConsoleTarget); s_ConsoleTarget.Layout = @"[${date:format=HH\:mm\:ss.fff}] ${logger} >> ${message}"; var s_ConsoleRule = new LoggingRule("*", LogLevel.Trace, s_ConsoleTarget); s_Config.LoggingRules.Add(s_ConsoleRule); var s_FileTarget = new FileTarget(); s_Config.AddTarget("file", s_FileTarget); s_FileTarget.FileName = "${basedir}/GrooveCaster.log"; s_FileTarget.Layout = @"[${date:format=HH\:mm\:ss.fff}] ${logger} >> ${message}"; s_FileTarget.ArchiveFileName = "${basedir}/GrooveCaster.{#}.log"; s_FileTarget.ArchiveEvery = FileArchivePeriod.Day; s_FileTarget.ArchiveNumbering = ArchiveNumberingMode.Date; s_FileTarget.ArchiveDateFormat = "yyyMMdd"; var s_FileRule = new LoggingRule("*", LogLevel.Trace, s_FileTarget); s_Config.LoggingRules.Add(s_FileRule); LogManager.Configuration = s_Config; }
public static void InitializeLogging() { var config = new LoggingConfiguration(); Target debuggerTarget = new DebuggerTarget() { Layout = "${longdate}|${level}|${logger}|${message} ${exception:format=tostring}" }; Target consoleTarget = new ColoredConsoleTarget() { Layout = "${longdate}|${level}|${logger}|${message} ${exception:format=tostring}" }; #if !DEBUG debuggerTarget = new AsyncTargetWrapper(debuggerTarget); consoleTarget = new AsyncTargetWrapper(consoleTarget); #else new AsyncTargetWrapper().Wrap(); // Placeholder for optimizing imports #endif config.AddTarget("debugger", debuggerTarget); config.AddTarget("console", consoleTarget); var debuggerRule = new LoggingRule("*", LogLevel.Trace, debuggerTarget); config.LoggingRules.Add(debuggerRule); var consoleRule = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(consoleRule); LogManager.Configuration = config; }
public void InitNLog() { // Step 1. Create configuration object NLog.Config.LoggingConfiguration gConfig = new NLog.Config.LoggingConfiguration(); // Step 2. Create targets and add them to the configuration NLog.Targets.ColoredConsoleTarget consoleTarget = new NLog.Targets.ColoredConsoleTarget(); gConfig.AddTarget("console", consoleTarget); NLog.Targets.FileTarget fileTarget = new NLog.Targets.FileTarget(); gConfig.AddTarget("file", fileTarget); // Step 3. Set target properties consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; fileTarget.FileName = System.IO.Directory.GetCurrentDirectory() + "/${shortdate}/${logger}.log"; fileTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; UnityEngine.Debug.Log(fileTarget.FileName); // Step 4. Define rules NLog.Config.LoggingRule rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, consoleTarget); gConfig.LoggingRules.Add(rule1); NLog.Config.LoggingRule rule2 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget); gConfig.LoggingRules.Add(rule2); // Step 5. Activate the configuration NLog.LogManager.Configuration = gConfig; }
private static void SetupLogging() { // Step 1. Create configuration object LoggingConfiguration config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); FileTarget fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); fileTarget.FileName = "${basedir}/file.txt"; // Step 3. Set target properties consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; fileTarget.Layout = "${date:format=HH\\:MM\\:ss} ${message}"; // Step 4. Define rules LoggingRule rule = new LoggingRule("*", LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule); rule = new LoggingRule("*", LogLevel.Debug, fileTarget); config.LoggingRules.Add(rule); // Step 5. Activate the configuration LogManager.Configuration = config; }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public void ConfigureConsoleOutput() { var consoleTarget = new ColoredConsoleTarget(); consoleTarget.Layout = @"${date:universalTime=true:format=HH\:mm\:ss.fff} ${message} ${exception:format=Message}"; consoleTarget.UseDefaultRowHighlightingRules = false; consoleTarget.RowHighlightingRules.Clear(); consoleTarget.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( "level == LogLevel.Trace and starts-with('${message}','[THREAD:')", ConsoleOutputColor.Cyan, ConsoleOutputColor.Black)); consoleTarget.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( "level == LogLevel.Trace", ConsoleOutputColor.DarkCyan, ConsoleOutputColor.Black)); consoleTarget.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( "level == LogLevel.Debug", ConsoleOutputColor.DarkGray, ConsoleOutputColor.Black)); consoleTarget.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( "level == LogLevel.Info", ConsoleOutputColor.White, ConsoleOutputColor.Black)); consoleTarget.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( "level == LogLevel.Warn", ConsoleOutputColor.Yellow, ConsoleOutputColor.Black)); consoleTarget.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( "level >= LogLevel.Error", ConsoleOutputColor.Red, ConsoleOutputColor.Black)); LogManager.Configuration.AddTarget(PlainTextConsoleTargetName, consoleTarget); var consoleRule = new LoggingRule(PlainTextLoggerName, LogLevel.Trace, consoleTarget); LogManager.Configuration.LoggingRules.Add(consoleRule); LogManager.ReconfigExistingLoggers(); }
private static void Configure(INewRelicConfig config) { config = config ?? NewRelicConfig.Instance; LoggingConfiguration loggingConfiguration = new LoggingConfiguration(); ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget { Name = "Console" }; loggingConfiguration.AddTarget("Console", consoleTarget); loggingConfiguration.LoggingRules.Add(new LoggingRule("*", ToNLogLevel(config.LogLevel), consoleTarget)); // Store the LogLevel so it can be fetched by consumers LogLevel = config.LogLevel; if (config.LogFilePath.IsValidString() && config.LogFileName.IsValidString()) { long archiveAboveSize = config.LogLimitInKiloBytes == 0 ? long.MaxValue : config.LogLimitInKiloBytes * 1024; FileTarget fileTarget = new FileTarget { KeepFileOpen = true, ConcurrentWrites = false, FileName = Path.Combine(config.LogFilePath, config.LogFileName), MaxArchiveFiles = 1, ArchiveAboveSize = archiveAboveSize, Name = "File", }; loggingConfiguration.AddTarget("File", fileTarget); loggingConfiguration.LoggingRules.Add(new LoggingRule("*", ToNLogLevel(config.LogLevel), fileTarget)); } NLogManager.Configuration = loggingConfiguration; }
public ExamplePrograms() { var loggerNamePattern = "BitSharp.Examples.*"; var logLevel = LogLevel.Info; // log layout format var layout = "${message} ${exception:separator=\r\n:format=message,type,method,stackTrace:maxInnerExceptionLevel=10:innerExceptionSeparator=\r\n:innerFormat=message,type,method,stackTrace}"; // initialize logging configuration var config = new LoggingConfiguration(); // create console target var consoleTarget = new ColoredConsoleTarget(); consoleTarget.Layout = layout; config.AddTarget("console", consoleTarget); config.LoggingRules.Add(new LoggingRule(loggerNamePattern, logLevel, consoleTarget)); // create debugger target, if attached if (Debugger.IsAttached) { var debuggerTarget = new DebuggerTarget(); debuggerTarget.Layout = layout; config.AddTarget("debugger", debuggerTarget); config.LoggingRules.Add(new LoggingRule(loggerNamePattern, logLevel, debuggerTarget)); } LogManager.Configuration = config; logger = LogManager.GetCurrentClassLogger(); }
public static Logger BuildLogger() { var consoleTarget = new ColoredConsoleTarget { Layout = "${message} ${exception:format=tostring}" }; var fileName = Path.Combine(Path.GetTempPath(), "NancyOnKayak", "WebsiteLog_${shortdate}.log"); Console.WriteLine("Logging to:" + fileName); var fileTarget = new FileTarget { FileName = fileName, Layout = "${longdate} ${message} ${exception:format=tostring}", AutoFlush = true, }; var config = new LoggingConfiguration { LoggingRules = { new LoggingRule("*", LogLevel.Debug, consoleTarget), new LoggingRule("*", LogLevel.Debug, fileTarget), } }; config.AddTarget("file", fileTarget); config.AddTarget("console", consoleTarget); LogManager.Configuration = config; return LogManager.GetLogger(""); }
public static void Configure() { // 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); // Step 3. Set target properties consoleTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}"; fileTarget.FileName = "${basedir}/SimplePerformanceMeter.txt"; fileTarget.Layout = "${message}"; // Step 4. Define rules var rule1 = new LoggingRule("*", LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", LogLevel.Debug, fileTarget); config.LoggingRules.Add(rule2); // Step 5. Activate the configuration LogManager.Configuration = config; }
public static void UseNLog(this IHost host) { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); var layout = @"${longdate}|${level:uppercase=true}|${threadid}|${logger}|${message}"; consoleTarget.Layout = layout; fileTarget.FileName = @"${tempdir}\${processname}\Log\${processname}.${processinfo:Id}.log"; fileTarget.ArchiveFileName = @"${tempdir}\${processname}\Log\${processname}.${processinfo:Id}.{###}.log"; fileTarget.ArchiveEvery = FileArchivePeriod.Day; fileTarget.ArchiveAboveSize = 1024000; fileTarget.ArchiveNumbering = ArchiveNumberingMode.Rolling; fileTarget.MaxArchiveFiles = 10; fileTarget.ConcurrentWrites = false; fileTarget.KeepFileOpen = false; fileTarget.Layout = layout; config.LoggingRules.Add(new LoggingRule("*", NLog.LogLevel.Debug, consoleTarget)); config.LoggingRules.Add(new LoggingRule("*", NLog.LogLevel.Info, fileTarget)); LogManager.Configuration = config; host.Container.RegisterType(typeof (ILogger<>), typeof (NLogger<>)); }
public static void ConfigureNLog() { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget { Layout = "${level:uppercase=true}|${logger}|${message}${onexception:${newline}${exception:format=tostring}}" }; config.AddTarget("console", consoleTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, consoleTarget)); var fileTarget = new FileTarget { FileName = "${basedir}/nsb_log_${date:format=yyyy-MM-dd}.txt", ArchiveDateFormat = "yyyy-MM-dd", Layout = "${longdate}|${level:uppercase=true}|${logger}|${message}${onexception:${newline}${exception:format=tostring}}", ArchiveAboveSize = 10 * 1024 *1024, ArchiveEvery = FileArchivePeriod.Day, ArchiveNumbering = ArchiveNumberingMode.Rolling, MaxArchiveFiles = 10, KeepFileOpen = false }; config.AddTarget("file", fileTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget)); LogManager.Configuration = config; }
public override void Load() { // log layout format var layout = "${date:format=hh\\:mm\\:ss tt} ${pad:padding=6:inner=${level:uppercase=true}} ${message} ${exception:separator=\r\n:format=message,type,method,stackTrace:maxInnerExceptionLevel=10:innerExceptionSeparator=\r\n:innerFormat=message,type,method,stackTrace}"; // initialize logging configuration var config = new LoggingConfiguration(); // create console target if (!Debugger.IsAttached) { var consoleTarget = new ColoredConsoleTarget(); consoleTarget.Layout = layout; config.AddTarget("console", consoleTarget); config.LoggingRules.Add(new LoggingRule("*", this.logLevel, consoleTarget)); } else { var consoleTarget = new DebuggerTarget(); consoleTarget.Layout = layout; config.AddTarget("console", consoleTarget); config.LoggingRules.Add(new LoggingRule("*", this.logLevel, consoleTarget)); } // activate configuration and bind LogManager.Configuration = config; }
public static void BuildLogger() { var consoleTarget = new ColoredConsoleTarget { Layout = "${message} ${exception:format=tostring}" }; var debuggerTarget = new DebuggerTarget() { Layout = "${message} ${exception:format=tostring}" }; var consoleRule = new LoggingRule("*", LogLevel.Debug, consoleTarget); var debuggerRule = new LoggingRule("*", LogLevel.Debug, debuggerTarget); var config = new LoggingConfiguration(); config.LoggingRules.Add(consoleRule); config.LoggingRules.Add(debuggerRule); config.AddTarget("debugger", debuggerTarget); config.AddTarget("console", consoleTarget); LogManager.Configuration = config; }
private void ConfigureLogger() { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); var logsDirPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Yakuza", "Jira Assistant", "Logs"); if (Directory.Exists(logsDirPath) == false) Directory.CreateDirectory(logsDirPath); var fileTarget = new FileTarget { Name = "main", FileName = Path.Combine(logsDirPath, "Jira Assistant.log"), Layout = "${longdate} ${uppercase:${level}} ${message} ${exception:format=tostring}", ArchiveFileName = Path.Combine(logsDirPath, "Jira Assistant.{#}.log"), ArchiveEvery = FileArchivePeriod.Day, ArchiveNumbering = ArchiveNumberingMode.Rolling, MaxArchiveFiles = 3, ConcurrentWrites = true }; config.AddTarget("file", fileTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, consoleTarget)); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, fileTarget)); LogManager.Configuration = config; }
private void configureLogger() { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); consoleTarget.Layout = @"${date:format=HH\:MM\:ss} ${logger} ${message}"; fileTarget.FileName = "${basedir}/logs/${shortdate}.log"; fileTarget.EnableFileDelete = true; fileTarget.DeleteOldFileOnStartup = true; fileTarget.Layout = "${message}"; var rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", LogLevel.Trace, fileTarget); config.LoggingRules.Add(rule2); LogManager.Configuration = config; log = LogManager.GetLogger("SeleniumTests"); }
static void ConfigureNLog() { const string logLayout = "[${date:format=HH\\:mm} ${logger}.${callsite:className=False:methodName=True}] " + "${message}${onexception:${newline}${exception:format=ToString}}"; var consoleTarget = new ColoredConsoleTarget { Name = "Console", Layout = logLayout, }; var rowHighlightingRules = new[] { new ConsoleRowHighlightingRule("level == LogLevel.Fatal", ConsoleOutputColor.White, ConsoleOutputColor.Red), new ConsoleRowHighlightingRule("level == LogLevel.Error", ConsoleOutputColor.Red, ConsoleOutputColor.NoChange), new ConsoleRowHighlightingRule("level == LogLevel.Warn", ConsoleOutputColor.Yellow, ConsoleOutputColor.NoChange), new ConsoleRowHighlightingRule("level == LogLevel.Info", ConsoleOutputColor.White, ConsoleOutputColor.NoChange), new ConsoleRowHighlightingRule("level == LogLevel.Debug", ConsoleOutputColor.Gray, ConsoleOutputColor.NoChange), new ConsoleRowHighlightingRule("level == LogLevel.Trace", ConsoleOutputColor.DarkGray, ConsoleOutputColor.NoChange), }; consoleTarget.RowHighlightingRules.Clear(); foreach (var highlightingRule in rowHighlightingRules) { consoleTarget.RowHighlightingRules.Add(highlightingRule); } LogManager.Configuration = new LoggingConfiguration(); LogManager.Configuration.AddTarget(consoleTarget); LogManager.Configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, consoleTarget)); LogManager.ReconfigExistingLoggers(); }
public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory) { #if DNX451 var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); consoleTarget.Layout = @"${date:format=HH\\:MM\\:ss} ${ndc} ${logger} ${message} "; var rule1 = new LoggingRule("*", NLog.LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule1); loggerFactory.AddNLog(new global::NLog.LogFactory(config)); #endif app.UseErrorPage() .UseStaticFiles() .UseIdentity() .UseFacebookAuthentication() .UseGoogleAuthentication() .UseTwitterAuthentication() .UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller}/{action}/{id?}", defaults: new { controller = "Home", action = "Index" }); }); //Populates the Admin user and role SampleData.InitializeIdentityDatabaseAsync(app.ApplicationServices).Wait(); }
// ------------------------------------------ // Logs Management // ------------------------------------------ protected void SetupLogging() { var path = ConfigManager.GetInstance().Find("debug.log-file", null); if (null == path) { return; } LoggingConfiguration config = new LoggingConfiguration(); ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget(); consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; config.AddTarget("console", consoleTarget); FileTarget fileTarget = new FileTarget(); fileTarget.FileName = path; fileTarget.Layout = "${message}"; fileTarget.CreateDirs = true; config.AddTarget("file", fileTarget); LoggingRule rule1 = new LoggingRule("*", LogLevel.Info, consoleTarget); config.LoggingRules.Add(rule1); LoggingRule rule2 = new LoggingRule("*", LogLevel.Info, fileTarget); config.LoggingRules.Add(rule2); LoggingRule rule3 = new LoggingRule("*", LogLevel.Warn, consoleTarget); config.LoggingRules.Add(rule3); LoggingRule rule4 = new LoggingRule("*", LogLevel.Warn, fileTarget); config.LoggingRules.Add(rule4); // Ready LogManager.ReconfigExistingLoggers(); LogManager.Configuration = config; Host.Log(this, "STARTING LOGGING:" + fileTarget.FileName); }
public static void InicializaLog(ArchivoConfig lee, EnumNivelLog lvlLog, string fileName, string tipo = "") { try { BASE_DIR = lee.LogPath; MAX_SIZE_FILE = lee.LogMaxFileSize; NUMERING_WITH_SEQUENTIAL = lee.NumeringWithSecuential; LEVEL_LOG = lvlLog; //(LogLevel)lee.LevelLog; FILE_NAME = fileName; } catch { } if (!Directory.Exists(BASE_DIR)) { Directory.CreateDirectory(BASE_DIR); } LoggingConfiguration confLog = new LoggingConfiguration(); console = new ColoredConsoleTarget { Name = "console", Layout = "${shortdate} ${level} ${message}" }; fileTargetM = new FileTarget { FileName = BASE_DIR + FILE_NAME, Layout = "${message}", ArchiveAboveSize = MAX_SIZE_FILE, ArchiveNumbering = ArchiveNumberingMode.Sequence }; LogLevel lv = LogLevel.Off; switch(LEVEL_LOG) { case EnumNivelLog.Trace: lv = LogLevel.Trace; break; case EnumNivelLog.Debug: lv = LogLevel.Debug; break; case EnumNivelLog.Info: lv = LogLevel.Info; break; case EnumNivelLog.Error: lv = LogLevel.Error; break; case EnumNivelLog.Warn: lv = LogLevel.Warn; break; case EnumNivelLog.Fatal: lv = LogLevel.Fatal; break; } logRuleConsole = new NLog.Config.LoggingRule("*", lv, console); logRuleFileM = new NLog.Config.LoggingRule("*", lv, fileTargetM); confLog.AddTarget("console", console); confLog.AddTarget("fileM", fileTargetM); confLog.LoggingRules.Add(logRuleConsole); confLog.LoggingRules.Add(logRuleFileM); #if DEBUG LogManager.ThrowExceptions = true; #endif LogManager.Configuration = confLog; logM += new LogMessageGenerator(LogMensaje); }
public static void AddConsoleLoggerToLogginConfig(LoggingConfiguration logConfig) { var consoleLogger = new ColoredConsoleTarget(); consoleLogger.Name = "ConsoleLogger"; consoleLogger.Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} ${logger}:${message};${exception}"; logConfig.AddTarget(consoleLogger); logConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, consoleLogger)); }
public void SetUp() { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget {Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}"}; var rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(rule1); LogManager.Configuration = config; }
private static void InitializeNLog() { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); var consoleTargetRule = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(consoleTargetRule); LogManager.Configuration = config; LogManager.ReconfigExistingLoggers(); }
internal static void Configure() { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget { Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}" }; config.AddTarget("console", consoleTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, consoleTarget)); LogManager.Configuration = config; }
/// <summary> /// Configures console logging (Trace level). /// </summary> private static void ConfigureConsoleTarget(LoggingConfiguration config) { var consoleTarget = new ColoredConsoleTarget { Layout = LogLayout }; config.AddTarget("console", consoleTarget); var consoleTargetRule = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(consoleTargetRule); }
public void WordHighlightingTextTest() { var target = new ColoredConsoleTarget { Layout = "${logger} ${message}" }; target.WordHighlightingRules.Add( new ConsoleWordHighlightingRule { ForegroundColor = ConsoleOutputColor.Red, Text = "at" }); AssertOutput(target, "The Cat Sat At The Bar.", new string[] { "The C", "at", " S", "at", " At The Bar." }); }
static void ConfigureLogging() { LoggingConfiguration config = new LoggingConfiguration(); ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; LoggingRule rule = new LoggingRule("*", LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule); LogManager.Configuration = config; }
private static void ZeNLog() { var logger = NLog.LogManager.GetCurrentClassLogger(); // Configure the static logger after getting a logger var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget { Layout = @"${message}"}; config.AddTarget("console", consoleTarget); config.LoggingRules.Add(new LoggingRule("*", NLog.LogLevel.Debug, consoleTarget)); LogManager.Configuration = config; logger.Info("Bar to u 2"); //this is written to console }
private static void setupLogging() { var conf = new LoggingConfiguration(); var coloredConsoleTarget = new ColoredConsoleTarget { Name = "Console", Layout = @"${date:format=HH\:MM\:ss} ${logger} ${message}" }; var consoleRule = new LoggingRule("*", LogLevel.Trace, coloredConsoleTarget); conf.AddTarget("Console", coloredConsoleTarget); conf.LoggingRules.Add(consoleRule); LogManager.Configuration = conf; }
private static void SetupNlog() { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); consoleTarget.Layout = @"${message} ${exception:format=tostring}"; consoleTarget.UseDefaultRowHighlightingRules = true; var rule1 = new LoggingRule("*", LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule1); LogManager.Configuration = config; }
/// <summary> /// Configuring the logger. /// </summary> private void ConfigureLogging() { var coloredConsoleTarget = new ColoredConsoleTarget { Layout = "${date:format=yyyy-MM-dd} ${time:format=hh:mm:ss} [${level}] ${message}" }; var loggingRule = new LoggingRule("*", LogLevel.Debug, coloredConsoleTarget); LogManager.Configuration = new LoggingConfiguration(); LogManager.Configuration.AddTarget("Console", coloredConsoleTarget); LogManager.Configuration.LoggingRules.Add(loggingRule); LogManager.ReconfigExistingLoggers(); _log = LogManager.GetCurrentClassLogger(); }
public Logger(bool isClassLogger = true) { var appName = Environment.GetEnvironmentVariable("AppName"); #if !UNITY_5_3_OR_NEWER var config = new NLog.Config.LoggingConfiguration(); string logFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "../../logs"); if (!Directory.Exists(logFolder)) { Directory.CreateDirectory(logFolder); } string logFilePath = Path.Combine(logFolder, appName + ".log"); Console.WriteLine("CreateLogFile: " + logFilePath); var logfile = new NLog.Targets.FileTarget("logfile") { FileName = logFilePath, Layout = new NLog.Layouts.SimpleLayout("${longdate} [${level:uppercase=true}] [${threadid}] ${callsite} - ${message}"), ArchiveFileName = "${basedir}/logs/archived/" + appName + ".{#####}.log", ArchiveAboveSize = 100000000 /* 100 MB */, ArchiveNumbering = ArchiveNumberingMode.Sequence, ConcurrentWrites = true, KeepFileOpen = false, MaxArchiveFiles = 10, }; if (!isClassLogger) { logfile.Layout = new NLog.Layouts.SimpleLayout("${longdate} [${level:uppercase=true}] [${threadid}] ${logger} - ${message}"); } var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole"); AsyncTargetWrapper wrapper = new AsyncTargetWrapper(); wrapper.WrappedTarget = logfile; wrapper.QueueLimit = 5000; wrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Grow; AsyncTargetWrapper wrapper2 = new AsyncTargetWrapper(); wrapper2.WrappedTarget = logconsole; wrapper2.QueueLimit = 5000; wrapper2.OverflowAction = AsyncTargetWrapperOverflowAction.Grow; config.AddTarget("asyncFile", wrapper); config.AddTarget("asyncConsole", wrapper2); config.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, wrapper2); config.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Fatal, wrapper); NLog.LogManager.Configuration = config; if (isClassLogger) { NLogger = NLog.LogManager.GetCurrentClassLogger(); } else { NLogger = NLog.LogManager.GetLogger(appName); } #else string logFolder = Path.Combine(Unity.Common.IOUtil.persistentDataPath, "logs"); if (!Directory.Exists(logFolder)) { Directory.CreateDirectory(logFolder); } string logFilePath = Path.Combine(logFolder, appName + ".log"); Console.WriteLine("CreateLogFile: " + logFilePath); var logfile = new NLog.Targets.FileTarget("logfile") { FileName = logFilePath, Layout = new NLog.Layouts.SimpleLayout("${longdate} [${level:uppercase=true}] [${threadid}] ${callsite} - ${message}"), ArchiveFileName = "${basedir}/logs/archived/" + appName + ".{#####}.log", ArchiveAboveSize = 100000000 /* 100 MB */, ArchiveNumbering = ArchiveNumberingMode.Sequence, ConcurrentWrites = true, KeepFileOpen = false, MaxArchiveFiles = 10, }; if (!isClassLogger) { logfile.Layout = new NLog.Layouts.SimpleLayout("${longdate} [${level:uppercase=true}] [${threadid}] ${logger} - ${message}"); } AsyncTargetWrapper wrapper = new AsyncTargetWrapper(); wrapper.WrappedTarget = logfile; wrapper.QueueLimit = 5000; wrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Grow; AsyncTargetWrapper wrapperUnity = new AsyncTargetWrapper(); if (isClassLogger) { wrapperUnity.WrappedTarget = Unity.Common.LogUtil.CreateUnityConsoleTarget("unityconsole", "${longdate} [${level:uppercase=true}] [${threadid}] ${callsite} - ${message}"); } else { wrapperUnity.WrappedTarget = Unity.Common.LogUtil.CreateUnityConsoleTarget("unityconsole", "${longdate} [${level:uppercase=true}] [${threadid}] ${logger} - ${message}"); } wrapperUnity.QueueLimit = 5000; wrapperUnity.OverflowAction = AsyncTargetWrapperOverflowAction.Grow; if (isClassLogger) { NLogger = Unity.Common.LogUtil.GetLogger(null, (cfg) => { cfg.AddTarget("asyncFile", wrapper); cfg.AddTarget("asyncConsole", wrapperUnity); cfg.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, wrapperUnity); cfg.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Fatal, wrapper); }); } else { NLogger = Unity.Common.LogUtil.GetLogger(appName, (cfg) => { cfg.AddTarget("asyncFile", wrapper); cfg.AddTarget("asyncConsole", wrapperUnity); cfg.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, wrapperUnity); cfg.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Fatal, wrapper); }); } #endif }