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
}
