void RunNLog(long iterations)
{
Stopwatch stopwatch = new Stopwatch();
Console.WriteLine("Testing NLog messages...");
var config = new NLog.Config.LoggingConfiguration();
var fileTarget = new NLog.Targets.FileTarget();
fileTarget.FileName = @"log\nlog.txt";
fileTarget.Layout = "${date:format=yyyy-MM-dd.HH.mm.ss.ffffff} ${processid}/${threadid} ${level}: ${message}";
var asyncWrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper(fileTarget, 1000, NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Grow);
//config.AddTarget("file", asyncWrapper);
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, asyncWrapper);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
var logger = NLog.LogManager.GetLogger("Benchmark");
// Prepare strings to write because string concatenation also takes some time
string[] strings = new string[iterations];
for (long i = 1; i <= iterations; i++)
{
strings[i - 1] = "Benchmark message - " + i;
}
stopwatch.Start();
long percent = 0;
for (long i = 1; i <= iterations; i++)
{
if (showProgress)
{
long newPercent = i * 100 / iterations;
if (newPercent > percent)
{
percent = newPercent;
Console.CursorLeft = 0;
Console.Write(" " + percent.ToString("##0") + " %");
}
}
switch (messageType)
{
case 0:
logger.Trace("Benchmark message - " + i);
break;
case 1:
logger.Trace(strings[i - 1]);
break;
case 2:
logger.Trace("Benchmark message");
break;
}
}
Console.CursorLeft = 0;
Console.Write(" ");
Console.CursorLeft = 0;
stopwatch.Stop();
long nanoseconds = (long) Math.Round((decimal) stopwatch.ElapsedTicks / Stopwatch.Frequency * 1000000000 / iterations);
nanoseconds -= emptyLoopTime;
Console.WriteLine(" " + nanoseconds.ToString().PadLeft(8) + " ns/call");
// Make sure all log items are written, as long as we have the time to wait for it
Stopwatch flFlushStopwatch = new Stopwatch();
flFlushStopwatch.Start();
NLog.LogManager.Flush();
flFlushStopwatch.Stop();
Console.WriteLine("Flushing NLog to files took " + flFlushStopwatch.ElapsedMilliseconds + " ms");
Console.WriteLine();
GC.Collect();
}
public void InitializeLogger()
{
var config = new NLog.Config.LoggingConfiguration();
LogManager.Configuration = config;
const string layout =
@"${date:format=yyyy-MM-dd HH\:mm\:ss,fff} ${level:upperCase=True} ${logger} ${message}${newline}${onexception:Process\: ${processname}${newline}Process time\: ${processtime}${newline}Process ID\: ${processid}${newline}Thread ID\: ${threadid}${newline}Details\:${newline}${exception:format=ToString}}";
var boxTarget = new RichTextBoxTarget
{
Layout = layout,
ControlName = "syntaxRichTextBox1",
FormName = "MainDlg",
UseDefaultRowColoringRules = false
};
boxTarget.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Warn", "Orange", "White",
FontStyle.Regular));
boxTarget.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Error", "Red", "White",
FontStyle.Regular));
boxTarget.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Fatal", "DarkViolet", "White",
FontStyle.Regular));
var traceTarget = new TraceTarget {
Layout = layout
};
config.AddTarget("box", boxTarget);
config.AddTarget("trace", traceTarget);
var r1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Warn, boxTarget);
var r2 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, traceTarget);
config.LoggingRules.Add(r1);
config.LoggingRules.Add(r2);
LogManager.Configuration = config;
}
public void Compose(IUnityContainer container)
{
var testOutputTarget = new TestOutputHelperTarget(_output);
testOutputTarget.Layout = Layout.FromString(Constants.Logging.DefaultLayout);
var rule = new NLog.Config.LoggingRule("*", LogLevel.Debug, testOutputTarget);
container.RegisterInstance("TestOutputHelper", rule);
}
public void Aggregate_And_AppendProvider()
{
//def console
LoggerFactory.Factory.AddConsole(LogLevel.Trace);
//print 1 line
_logger.Info("------- console -------");
var config = new NLog.Config.LoggingConfiguration();
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
var factory = new NLog.LogFactory(config);
//append NLog
LoggerFactory.Factory.AddNLog(factory);
//print 2 line
_logger.Info("------- console & nlog -------");
}
/// <summary>
/// Initializes the configuration of NLog.LogManager with logging to console + file.
/// </summary>
public static void initialize()
{
// create configuration object
var config = new NLog.Config.LoggingConfiguration();
// create targets and add them to the configuration
// --- console
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
// --- file
var fileTarget = new NLog.Targets.FileTarget();
config.AddTarget("file", fileTarget);
// set target properties
consoleTarget.Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} - ${message}";
fileTarget.FileName = getLogFileName();
fileTarget.Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} [${logger}] ${message}";
// define rules
var rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, consoleTarget);
config.LoggingRules.Add(rule1);
var rule2 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget);
config.LoggingRules.Add(rule2);
// activate the configuration
NLog.LogManager.Configuration = config;
}
private static void ConfigurateFileLogger(string logDir, NLog.Config.LoggingConfiguration logCfg, string loggerName)
{
var fileName = Path.Combine(logDir, loggerName + ".log");
var fileTarget = CreateFileTarget(loggerName, fileName);
logCfg.AddTarget(loggerName, fileTarget);
var rule = new NLog.Config.LoggingRule(loggerName, NLog.LogLevel.Trace, fileTarget);
logCfg.LoggingRules.Add(rule);
}
public static NLog.Targets.MemoryTarget CreateMemoryTargetLogger(LogLevel level)
{
var memLogger = new NLog.Targets.MemoryTarget();
memLogger.Layout = "${level:uppercase=true} | ${logger} | ${message}";
var rule = new NLog.Config.LoggingRule("*", level, memLogger);
NLog.LogManager.Configuration.LoggingRules.Add(rule);
NLog.LogManager.Configuration.Reload();
return(memLogger);
}
static void NLogConfigure()
{
var config = new NLog.Config.LoggingConfiguration();
var ftarget = new NLog.Targets.FileTarget()
{
FileName = "${basedir}/launcher.txt", Layout = "${longdate}: ${message}"
};
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, ftarget);
config.AddTarget("file", ftarget);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
}
public Logger(string dir)
{
NLog.Config.LoggingConfiguration config = new NLog.Config.LoggingConfiguration();
NLog.Targets.FileTarget fileTarget = new NLog.Targets.FileTarget();
config.AddTarget("file", fileTarget);
fileTarget.FileName = System.IO.Path.Combine(dir, "log.txt");
fileTarget.Layout = "${date:format=MM/dd HH\\:mm\\:ss.ffff}|${level:uppercase=true:padding=6}| ${message}";
fileTarget.DeleteOldFileOnStartup = true;
NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
logger = NLog.LogManager.GetLogger("OnlineVideos");
}
private static void CreateTraceLabLoggingRule()
{
// Enable all messages from TraceLab
var allErrorsRule = new NLog.Config.LoggingRule();
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Info);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Trace);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Debug);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Warn);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Error);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Fatal);
allErrorsRule.LoggerNamePattern = "TraceLab*";
NLog.LogManager.Configuration.LoggingRules.Add(allErrorsRule);
}
public Logger(string dir)
{
NLog.Config.LoggingConfiguration config = new NLog.Config.LoggingConfiguration();
NLog.Targets.FileTarget fileTarget = new NLog.Targets.FileTarget();
config.AddTarget("file", fileTarget);
fileTarget.FileName = System.IO.Path.Combine(dir, "log.txt");
fileTarget.Layout = "${date:format=MM/dd HH\\:mm\\:ss.ffff}|${level:uppercase=true:padding=6}| ${message}";
fileTarget.DeleteOldFileOnStartup = true;
NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
logger = NLog.LogManager.GetLogger("OnlineVideos");
}
// ログをコマンド用に設定する
// Infoは出力しない
// Warn以上を標準エラー出力に出す
static void initializeLoggingRule()
{
var fact = Winium.Cruciatus.CruciatusFactory.Logger.Factory;
var target = new NLog.Targets.ConsoleTarget();
target.Error = true;
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Warn, target);
fact.Configuration.LoggingRules.Clear();
fact.Configuration.LoggingRules.Add(rule);
fact.ReconfigExistingLoggers();
}
private static void CreateTraceLabLoggingRule()
{
// Enable all messages from TraceLab
var allErrorsRule = new NLog.Config.LoggingRule();
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Info);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Trace);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Debug);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Warn);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Error);
allErrorsRule.EnableLoggingForLevel(NLog.LogLevel.Fatal);
allErrorsRule.LoggerNamePattern = "TraceLab*";
NLog.LogManager.Configuration.LoggingRules.Add(allErrorsRule);
}
/// <summary>
/// Destroys the logger.
/// </summary>
/// <param name="logger">The logger.</param>
internal static void DestroyLogger(ComponentLogger logger)
{
ComponentLoggerImplementation loggerImpl = logger as ComponentLoggerImplementation;
if (loggerImpl != null)
{
NLog.Config.LoggingRule loggingRule = TryFindRule(loggerImpl.Name);
lock (lockLoggingRules)
{
NLog.LogManager.Configuration.LoggingRules.Remove(loggingRule);
}
}
}
private static void ConfigurateConsoleLogger(NLog.Config.LoggingConfiguration logCfg)
{
Debug.Assert(logCfg != null);
var consoleTarget = new NLog.Targets.ColoredConsoleTarget()
{
Name = "console",
Layout = LoggingLayout,
};
logCfg.AddTarget("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, consoleTarget);
logCfg.LoggingRules.Add(rule1);
}
private static void ConfigurateDebuggerLogger(NLog.Config.LoggingConfiguration logCfg)
{
Debug.Assert(logCfg != null);
var debuggerTarget = new NLog.Targets.OutputDebugStringTarget()
{
Name = "debugger",
Layout = LoggingLayout
};
logCfg.AddTarget("debugger", debuggerTarget);
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, debuggerTarget);
logCfg.LoggingRules.Add(rule);
}
private static void ConfigureLogging()
{
var logConfig = new NLog.Config.LoggingConfiguration();
var consoleTarget = new NLog.Targets.ColoredConsoleTarget()
{
Layout = "[${level:uppercase=true}][${logger}] ${message}"
};
logConfig.AddTarget("console", consoleTarget);
var logRule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, consoleTarget);
logConfig.LoggingRules.Add(logRule1);
NLog.LogManager.Configuration = logConfig;
}
public static void MyClassInitialize(TestContext testContext)
{
var config = new NLog.Config.LoggingConfiguration();
var target = new NLog.Targets.DebuggerTarget();
config.AddTarget("debugger", target);
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, target);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
var _logger = NLog.LogManager.GetCurrentClassLogger();
_logger.Debug("Using programmatic config");
}
public void Attach()
{
if (rule != null)
{
throw new InvalidOperationException("NLogSpy already attached");
}
var config = logFactory.Configuration;
rule = new NLog.Config.LoggingRule(name, NLog.LogLevel.Trace, target);
config.AddTarget(target);
config.LoggingRules.Add(rule);
// IMPORTANT: The configuration is not updated until this property is reassigned, at
// which point all of the settings are updated all at once. We only "reuse" the existing
// config object to retain all of the previous settings.
logFactory.Configuration = config;
}
public void Detach()
{
if (rule == null)
{
throw new InvalidOperationException("NLogSpy not currently attached");
}
var config = logFactory.Configuration;
config.LoggingRules.Remove(rule);
config.RemoveTarget(target.Name);
rule = null;
// IMPORTANT: The configuration is not updated until this property is reassigned, at
// which point all of the settings are updated all at once. We only "reuse" the existing
// config object to retain all of the previous settings.
logFactory.Configuration = config;
}
/// <inheritdoc />
public virtual void ApplyConfiguration(LoggerOptions options)
{
CurrentOptions = options ?? throw new ArgumentNullException(nameof(options), "Null options are not allowed");
// Validate options
ValidateOptions(CurrentOptions);
// Reconfigure NLog
var fileTarget = new NLog.Targets.FileTarget("FileLog")
{
FileName = options.FileName,
ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence,
ArchiveOldFileOnStartup = options.IsArchiveOnStart,
Layout = options.LogMessageLayout ?? NLOG_LAYOUT,
EnableArchiveFileCompression = options.IsCompressed,
ArchiveAboveSize = options.SizePerFile.SizeInBytes,
MaxArchiveFiles = options.ArchiveCount
};
var configuration = new NLog.Config.LoggingConfiguration();
configuration.AddTarget(fileTarget);
// Configure rule
var filter = string.IsNullOrWhiteSpace(options.Filter) ? "*" : options.Filter;
var fileRule = new NLog.Config.LoggingRule(filter, options.Level.ToNLog(), fileTarget);
configuration.LoggingRules.Add(fileRule);
// Debug
if (options.LogToDebugStream)
{
var debugTarget = new NLog.Targets.DebuggerTarget("DebugLog")
{
Layout = options.LogMessageLayout ?? NLOG_LAYOUT
};
configuration.AddTarget(debugTarget);
var debugRule = new NLog.Config.LoggingRule(filter, options.Level.ToNLog(), debugTarget);
configuration.LoggingRules.Add(debugRule);
}
// Set configuration
NLog.LogManager.Configuration = configuration;
}
/// <summary>
/// Регистрируем правила Nlog для строки состояния
/// </summary>
/// <param name="methodName">Имя статического метода который будет вызываться при появлении сообщения.</param>
/// <param name="className">Имя класа в котором находится метод.</param>
public static void MakeNewStatusTargetForNlog(string methodName, string className)
{
NLog.Config.LoggingConfiguration config = LogManager.Configuration;
if (config.FindTargetByName("status") != null)
{
return;
}
NLog.Targets.MethodCallTarget targetLog = new NLog.Targets.MethodCallTarget();
targetLog.Name = "status";
targetLog.MethodName = methodName;
targetLog.ClassName = className;
targetLog.Parameters.Add(new NLog.Targets.MethodCallParameter("${message}"));
config.AddTarget("status", targetLog);
NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule("*", targetLog);
rule.EnableLoggingForLevel(LogLevel.Info);
config.LoggingRules.Add(rule);
LogManager.Configuration = config;
}
private static NLog.Logger CreateNLogLogger()
{
var config = new NLog.Config.LoggingConfiguration();
var target = new NLog.Targets.FileTarget
{
FileName = "nlog.log",
ConcurrentWrites = true
};
config.AddTarget("logfile", target);
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, target);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
return(NLog.LogManager.GetCurrentClassLogger());
}
/// <summary>
/// Creates the logging rules for each log level for given logger name
/// </summary>
/// <param name="loggerName">Name of the logger.</param>
/// <param name="logLevels">The log levels.</param>
private static void CreateLoggingRules(string loggerName, IEnumerable <TraceLab.Core.Settings.LogLevelItem> logLevels)
{
NLog.Config.LoggingRule loggingRule = null;
foreach (TraceLab.Core.Settings.LogLevelItem logLevelItem in logLevels)
{
if (logLevelItem.IsEnabled)
{
if (loggingRule == null)
{
loggingRule = CreateRule(loggerName, logLevelItem.Level);
}
loggingRule.EnableLoggingForLevel(logLevelItem.Level);
}
}
NLog.LogManager.ReconfigExistingLoggers();
}
public override void Load()
{
//Create bindings
Rebind<IStartupService>().To<StartupService>().InSingletonScope();
Rebind<IChunk>().To<Chunk>();
Rebind<INetworkPeer>().To<NetworkPeer>().InSingletonScope();
string path = Application.ExecutablePath.Substring(0, Application.ExecutablePath.Length - Path.GetFileName(Application.ExecutablePath).Length);
Rebind<IFileSystem>().To<StandardFileSystem>().InSingletonScope().WithConstructorArgument("workingDirectory", new FileReference(path + "assets/"));
Rebind<NetPeerConfiguration>().ToMethod(context => Kernel.Get<NetworkConfig>().CreateNetPeerConfig()).InSingletonScope();
Rebind<IConfigManager>().To<ConfigManager>().InSingletonScope().WithConstructorArgument("fileReference", new FileReference(Application.ExecutablePath).GetFileName() + "_config.json");
Rebind<ActorProvider>().To<ActorProvider>().InSingletonScope();
Rebind<IActor>().ToProvider<ActorProvider>();
//Logging config stuff
{
NLog.Config.LoggingConfiguration config = new NLog.Config.LoggingConfiguration();
//targets
NLog.Targets.FileTarget fileTarget = new NLog.Targets.FileTarget();
config.AddTarget("file", fileTarget);
NLog.Targets.ConsoleTarget consoleTarget = new NLog.Targets.ConsoleTarget();
config.AddTarget("console", fileTarget);
fileTarget.FileName = "${basedir}/${processname}_Log.txt";
fileTarget.Layout = "[${longdate}] [${level}] [${message}]";
consoleTarget.Layout = ">> [${date:format=HH\\:MM\\:ss}] [${level}] [${message}]";
//rules
NLog.Config.LoggingRule loggingRule;
loggingRule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget);
config.LoggingRules.Add(loggingRule);
loggingRule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, consoleTarget);
config.LoggingRules.Add(loggingRule);
//activate
NLog.LogManager.Configuration = config;
}
//Register services - Order is important services bound first get to register for events first and consequently receive events first.
IStartupService startup = Kernel.Get<IStartupService>();
startup.RegisterStartupType<IConfigManager>();
startup.RegisterStartupType<IMessageTypeManager>();
startup.RegisterStartupType<IBlockManager>();
startup.RegisterStartupType<IMap>();
}
/// <summary>
/// Creates the rule in the nlog manager with a given logger name and level
/// </summary>
/// <param name="loggerName">Name of the logger.</param>
/// <param name="level">The level.</param>
/// <returns></returns>
private static NLog.Config.LoggingRule CreateRule(string loggerName, NLog.LogLevel level)
{
NLog.Config.LoggingRule loggingRule = TryFindRule(loggerName);
// if it hasn't been created yet..
if (loggingRule == null)
{
loggingRule = new NLog.Config.LoggingRule();
loggingRule.LoggerNamePattern = loggerName;
foreach (NLog.Targets.Target target in NLog.LogManager.Configuration.ConfiguredNamedTargets)
{
loggingRule.Targets.Add(target);
}
NLog.LogManager.Configuration.LoggingRules.Add(loggingRule);
NLog.LogManager.ReconfigExistingLoggers();
}
return(loggingRule);
}
public ActivityLogger()
{
//CurrentLogLevel = LogLevel.Info;
string logLevel = string.Empty;
IList <NLog.Config.LoggingRule> lstLoggingRules = LogManager.Configuration.LoggingRules;
if (lstLoggingRules != null)
{
NLog.Config.LoggingRule loggingRule = lstLoggingRules[0];
CurrentLogLevel = loggingRule.Levels[0];
}
//this.DefaultActType = myUnit.ActionType.GetByID("action_undefined");
////this.DefaultLogType = myUnit.LogType.GetByID("logtype_undefined");
//this.DefaultActType = myUnit.ActionTypeRepository.GetByID("action_undefined");
//this.DefaultLogType = myUnit.LogTypeRepository.GetByID("logtype_undefined");
logger = LogManager.GetLogger("PMSWeb");
}
/// <summary>
/// Initializes the <see cref="NLog"/> logger with a config that is suitable for tests.
/// </summary>
public static void InitializeLogger()
{
// Step 1. Create configuration object
var config = new NLog.Config.LoggingConfiguration();
// Step 2. Create targets and add them to the configuration
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
// Step 3. Set target properties
consoleTarget.Layout = @"${message}";
// Step 4. Define rules
var rule1 = new NLog.Config.LoggingRule("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
// Step 5. Activate the configuration
NLog.LogManager.Configuration = config;
}
private static void ConfigRule(NLog.Config.LoggingRule rule, int minLevel)
{
//Disable all loglevel rules
for (int i = 0; i < 6; i++)
{
rule.DisableLoggingForLevel(LogLevel.FromOrdinal(i));
}
//Enable present loglevel rules up to maxLevel
if (minLevel > 0)
{
for (int i = 0; i <= minLevel; i++)
{
var logLevel = LogLevel.FromOrdinal(6 - i);
if (logLevel != LogLevel.Off)
{
rule.EnableLoggingForLevel(logLevel);
}
}
}
}
public void Aggregate_And_AppendProvider() {
//def console
LoggerManager.Factory.AddConsole(LogLevel.Trace);
_logger.Info("------- console -------");
var config = new NLog.Config.LoggingConfiguration();
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
var factory = new NLog.LogFactory(config);
//append NLog
LoggerManager.Factory.AddNLog(factory);
_logger.Info("------- console & nlog -------");
}
public static ILogixLogger ConfigureUserEventLogger(Configuration configuration)
{
string date = System.DateTime.Today.Year.ToString() +
System.DateTime.Today.Month.ToString() +
System.DateTime.Today.Day.ToString();
string fileName = string.Format("{0}_{1}_usereventlogs.log", configuration.ApplicationName, date);
NLog.Targets.FileTarget fileTarget = new NLog.Targets.FileTarget
{
FileName = System.IO.Path.Combine(configuration.BaseLocationOfLogFile, fileName),
Layout = "${date:format=yyyy/MMM/dd HH\\:mm\\:ss.ffff} | ${level:uppercase=true:padding=6} | ${message}",
ConcurrentWrites = true,
CreateDirs = true
};
NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget);
NLog.Config.LoggingConfiguration nlogConfiguration = new NLog.Config.LoggingConfiguration();
nlogConfiguration.LoggingRules.Add(rule);
NLog.LogManager.Configuration = nlogConfiguration;
NLog.Logger logger = NLog.LogManager.GetLogger("LogixLogger");
return(new LogixLogger(logger, configuration));
}
/// <summary>
/// Tries the find the logging rule based on the logger name in the nlog manager
/// </summary>
/// <param name="loggerName">Name of the logger.</param>
/// <returns></returns>
private static NLog.Config.LoggingRule TryFindRule(string loggerName)
{
NLog.Config.LoggingRule loggingRule = null;
IEnumerable <NLog.Config.LoggingRule> loggingRules;
//do a local copy over which finding the rule is going to be executed
lock (lockLoggingRules)
{
loggingRules = new List <NLog.Config.LoggingRule>(NLog.LogManager.Configuration.LoggingRules);
}
// Try to find the rule
foreach (NLog.Config.LoggingRule rule in loggingRules)
{
if (rule.LoggerNamePattern == loggerName)
{
loggingRule = rule;
break;
}
}
return(loggingRule);
}
public static void InitializeLogger()
{
var config = new NLog.Config.LoggingConfiguration();
var consoleLog = new NLog.Targets.ColoredConsoleTarget()
{
Name = "consoleLog"
};
consoleLog.Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} | ${pad:padding=-5:inner=${level:uppercase=true}} | ${logger} | ${message} ${exception:format=message}";
var filter = new NLog.Filters.ConditionBasedFilter();
filter.Condition = "equals('${logger}', 'Player.MessageProvider')";
filter.Action = NLog.Filters.FilterResult.Ignore;
var rule = new NLog.Config.LoggingRule("*", LogLevel.Debug, consoleLog);
rule.Filters.Add(filter);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
}
protected override void Configure(TestConfiguration config, Random random)
{
base.Configure(config, random);
var c = new NLog.Config.LoggingConfiguration();
var traceTarget = new NLog.Targets.TraceTarget();
traceTarget.Layout = "${message}";
c.AddTarget("trace", traceTarget);
var rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Error, traceTarget);
c.LoggingRules.Add(rule1);
NLog.LogManager.Configuration = c;
Logger = NLog.LogManager.GetCurrentClassLogger();
}
void RunNLog(long iterations)
{
Stopwatch stopwatch = new Stopwatch();
Console.WriteLine("Testing NLog messages...");
var config = new NLog.Config.LoggingConfiguration();
var fileTarget = new NLog.Targets.FileTarget();
fileTarget.FileName = @"log\nlog.txt";
fileTarget.Layout = "${date:format=yyyy-MM-dd.HH.mm.ss.ffffff} ${processid}/${threadid} ${level}: ${message}";
var asyncWrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper(fileTarget, 1000, NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Grow);
//config.AddTarget("file", asyncWrapper);
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, asyncWrapper);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
var logger = NLog.LogManager.GetLogger("Benchmark");
// Prepare strings to write because string concatenation also takes some time
string[] strings = new string[iterations];
for (long i = 1; i <= iterations; i++)
{
strings[i - 1] = "Benchmark message - " + i;
}
stopwatch.Start();
long percent = 0;
for (long i = 1; i <= iterations; i++)
{
if (showProgress)
{
long newPercent = i * 100 / iterations;
if (newPercent > percent)
{
percent = newPercent;
Console.CursorLeft = 0;
Console.Write(" " + percent.ToString("##0") + " %");
}
}
switch (messageType)
{
case 0:
logger.Trace("Benchmark message - " + i);
break;
case 1:
logger.Trace(strings[i - 1]);
break;
case 2:
logger.Trace("Benchmark message");
break;
}
}
Console.CursorLeft = 0;
Console.Write(" ");
Console.CursorLeft = 0;
stopwatch.Stop();
long nanoseconds = (long)Math.Round((decimal)stopwatch.ElapsedTicks / Stopwatch.Frequency * 1000000000 / iterations);
nanoseconds -= emptyLoopTime;
Console.WriteLine(" " + nanoseconds.ToString().PadLeft(8) + " ns/call");
// Make sure all log items are written, as long as we have the time to wait for it
Stopwatch flFlushStopwatch = new Stopwatch();
flFlushStopwatch.Start();
NLog.LogManager.Flush();
flFlushStopwatch.Stop();
Console.WriteLine("Flushing NLog to files took " + flFlushStopwatch.ElapsedMilliseconds + " ms");
Console.WriteLine();
GC.Collect();
}
protected void OnActionRecognizeActivated(object sender, EventArgs e)
{
TreeIter iter, imageiter;
//Создаем новый лог
if (RecognizeLog == null)
{
NLog.Config.LoggingConfiguration config = LogManager.Configuration;
RecognizeLog = new NLog.Targets.MemoryTarget();
RecognizeLog.Name = "recognizelog";
RecognizeLog.Layout = "${level} ${message}";
config.AddTarget("recognizelog", RecognizeLog);
NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule("*", LogLevel.Debug, RecognizeLog);
config.LoggingRules.Add(rule);
LogManager.Configuration = config;
}
else
{
RecognizeLog.Logs.Clear();
}
logger.Info("Запущен новый процесс распознования...");
if (!ImageList.GetIterFirst(out iter))
{
logger.Warn("Список изображений пуст. Остановка.");
return;
}
logger.Info("Всего документов: {0}", ImageList.IterNChildren());
progresswork.Text = "Распознование документов...";
progresswork.Adjustment.Upper = ImageList.IterNChildren();
MainClass.WaitRedraw();
do
{
if (ImageList.IterDepth(iter) == 0)
{
logger.Info((string)ImageList.GetValue(iter, 1));
//Получаем список изображений документа
int ImagesCount = ImageList.IterNChildren(iter);
Pixbuf[] Images = new Pixbuf [ImagesCount];
int i = 0;
ImageList.IterChildren(out imageiter, iter);
do
{
Images [i] = (Pixbuf)ImageList.GetValue(imageiter, 5);
i++;
} while (ImageList.IterNext(ref imageiter));
Document doc = (Document)ImageList.GetValue(iter, 3);
//Распознание QR кода с распознаванием типа документа
var qrResult = QRCodeRecognizer.TryParse(Images, ref doc);
//Если QR кода нет или не распознан попытка распознать другими способами
if (!qrResult)
{
logger.Warn("QR код не распознан или не указан в документе. Пытаемся распознать другими способами...");
if (doc == null)
{
logger.Warn("Тип не определён. Переходим к следующему...");
continue;
}
if (doc.Template == null)
{
logger.Warn("Шаблон распознования не указан. Переходим к следующему...");
continue;
}
logger.Info("Тип: {0}", doc.Name);
logger.Info("Количество страниц: {0}", ImagesCount);
logger.Info("Инициализация движка...");
RecognizeDoc tess = new RecognizeDoc(doc, Images);
tess.DiagnosticMode = checkDiagnostic.Active;
//FIXME Для теста
tess.parent = this;
try {
tess.Recognize();
} catch (Exception ex) {
QSMain.ErrorMessageWithLog(this, "Ошибка в модуле распознования!", logger, ex);
ShowLog();
}
}
else
{
ImageList.SetValue(iter, 7, doc.Name);
ImageList.SetValue(iter, 3, doc);
}
ImageList.SetValue(iter, 8, GetDocIconByState(doc.State));
}
progresswork.Adjustment.Value++;
MainClass.WaitRedraw();
}while(ImageList.IterNext(ref iter));
logger.Info("Выполнено");
progresswork.Text = "Выполнено";
progresswork.Fraction = 0;
CurrentDoc = (Document)ImageList.GetValue(CurrentDocIter, 3);
UpdateFieldsWidgets(true);
}
public static void InitializeLog (string logFileName = null, string logLevel = null)
{
// default parameters initialization from config file
if (String.IsNullOrEmpty (logFileName))
{
logFileName = System.Configuration.ConfigurationManager.AppSettings["logFilename"] ?? ("${basedir}/log/default_log_name.log");
}
if (String.IsNullOrEmpty (logLevel))
{
logLevel = System.Configuration.ConfigurationManager.AppSettings["logLevel"] = "Info";
}
// Trying to Parse log Level
LogLevel currentLogLevel;
try
{
currentLogLevel = LogLevel.FromString (logLevel);
}
catch
{
currentLogLevel = LogLevel.Info;
}
// Preparing Log Configuration
var config = new NLog.Config.LoggingConfiguration ();
// Console Output Config
if (!Console.IsOutputRedirected)
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget ();
consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}";
config.AddTarget ("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule ("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add (rule1);
}
// File Output
var fileTarget = new NLog.Targets.FileTarget ();
fileTarget.FileName = "${basedir}/log/" + logFileName;
fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\"";
fileTarget.ConcurrentWrites = true;
fileTarget.AutoFlush = true;
fileTarget.KeepFileOpen = true;
fileTarget.DeleteOldFileOnStartup = false;
fileTarget.ArchiveAboveSize = 2 * 1024 * 1024; // 2 Mb
fileTarget.MaxArchiveFiles = 10;
fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.Date;
fileTarget.ArchiveDateFormat = "yyyyMMdd_HHmmss";
// Setting output file writing to Async Mode
var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget);
// Adding "File" as one of the log targets
config.AddTarget ("file", wrapper);
// Configuring Log from Config File
fileTarget.FileName = logFileName;
var rule2 = new NLog.Config.LoggingRule ("*", currentLogLevel, fileTarget);
config.LoggingRules.Add (rule2);
// Saving Configurations
LogManager.Configuration = config;
}
/// <summary>
/// Log initialization.
/// </summary>
internal static void InitializeLog (string logFileName = null, string logLevel = null, InitializationOptions options = null)
{
if (options != null && !options.overrideNLogFileConfiguration && LogManager.Configuration == null)
return;
// default parameters initialization from config file
if (String.IsNullOrEmpty (logFileName))
logFileName = _logFileName ?? System.Configuration.ConfigurationManager.AppSettings["logFilename"];
if (String.IsNullOrEmpty (logFileName))
logFileName = ("${basedir}/log/" + typeof (ConsoleUtils).Namespace.Replace (".SimpleHelpers", "") + ".log");
if (String.IsNullOrEmpty (logLevel))
logLevel = _logLevel ?? (System.Configuration.ConfigurationManager.AppSettings["logLevel"] ?? "Info");
// check if log was initialized with same options
if (_logFileName == logFileName && _logLevel == logLevel)
return;
// try to parse loglevel
LogLevel currentLogLevel;
try { currentLogLevel = LogLevel.FromString (logLevel); }
catch { currentLogLevel = LogLevel.Info; }
// save current log configuration
_logFileName = logFileName;
_logLevel = currentLogLevel.ToString ();
// prepare log configuration
var config = new NLog.Config.LoggingConfiguration ();
// console output
if (!Console.IsOutputRedirected)
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget ();
consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}";
config.AddTarget ("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule ("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add (rule1);
}
// file output
var fileTarget = new NLog.Targets.FileTarget ();
fileTarget.FileName = logFileName;
fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\"";
fileTarget.ConcurrentWrites = true;
fileTarget.ConcurrentWriteAttemptDelay = 10;
fileTarget.ConcurrentWriteAttempts = 8;
fileTarget.AutoFlush = true;
fileTarget.KeepFileOpen = true;
fileTarget.DeleteOldFileOnStartup = false;
fileTarget.ArchiveAboveSize = 4 * 1024 * 1024; // 4 Mb
fileTarget.MaxArchiveFiles = 10;
fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence;
fileTarget.ArchiveDateFormat = "yyyyMMdd_HHmmss";
// set file output to be async (commented out since doesn't work on mono)
// var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget);
config.AddTarget ("file", fileTarget);
// configure log from configuration file
var rule2 = new NLog.Config.LoggingRule ("*", currentLogLevel, fileTarget);
config.LoggingRules.Add (rule2);
// External Log Target
if (options != null && options.targets != null)
{
foreach (var t in options.targets)
{
config.AddTarget (t);
config.LoggingRules.Add (new NLog.Config.LoggingRule ("*", currentLogLevel, t));
}
}
// set configuration options
LogManager.Configuration = config;
}
/// <summary>
/// Log initialization.
/// </summary>
internal static void InitializeLog (string logFileName = null, string logLevel = null, InitializationOptions initOptions = null, FlexibleOptions appOptions = null)
{
// default parameters initialization from config file
if (String.IsNullOrEmpty (logFileName))
logFileName = _logFileName ?? System.Configuration.ConfigurationManager.AppSettings["logFilename"];
if (String.IsNullOrEmpty (logFileName))
logFileName = ("${basedir}/log/" + typeof (ConsoleUtils).Namespace.Replace (".SimpleHelpers", "") + ".log");
if (String.IsNullOrEmpty (logLevel))
logLevel = _logLevel ?? (System.Configuration.ConfigurationManager.AppSettings["logLevel"] ?? "Info");
// check if log was initialized with same options
if (_logFileName == logFileName && _logLevel == logLevel)
return;
// try to parse loglevel
LogLevel currentLogLevel;
try { currentLogLevel = LogLevel.FromString (logLevel); }
catch { currentLogLevel = LogLevel.Info; }
// save current log configuration
_logFileName = logFileName;
_logLevel = currentLogLevel.ToString ();
// check initialization options
var localOptions = initOptions != null ? initOptions.Clone () : new InitializationOptions ();
// adjust options based on arguments
if (appOptions != null)
{
if (!localOptions.DisableLogFile.HasValue && appOptions.HasOption ("DisableLogFile"))
localOptions.DisableLogFile = appOptions.Get ("DisableLogFile", false);
if (localOptions.EnableLogTargets == null && !String.IsNullOrEmpty (appOptions.Get ("EnableLogTargets")))
localOptions.EnableLogTargets = appOptions.GetAsList ("EnableLogTargets").Where (i => !String.IsNullOrWhiteSpace (i)).Select (i => i.Trim ()).ToArray ();
if (localOptions.DisableLogTargets == null && !String.IsNullOrEmpty (appOptions.Get ("DisableLogTargets")))
localOptions.DisableLogTargets = appOptions.GetAsList ("DisableLogTargets").Where (i => !String.IsNullOrWhiteSpace (i)).Select (i => i.Trim ()).ToArray ();
}
// prepare list of enabled targets
HashSet<string> enabledTargets;
// if enabled log targets was provided, use it!
if (localOptions.EnableLogTargets != null && localOptions.EnableLogTargets.Count > 0)
{
enabledTargets = new HashSet<string> (localOptions.EnableLogTargets, StringComparer.OrdinalIgnoreCase);
}
// else we remove disabled target...
else
{
enabledTargets = new HashSet<string> (StringComparer.OrdinalIgnoreCase) { "console", "file" };
// set enabled targets
if (localOptions.Targets != null)
{
foreach (var i in localOptions.Targets)
{
foreach (var n in GetNLogTargetName (i))
enabledTargets.Add (n);
}
}
// remove disabled targets
if (localOptions.DisableLogTargets != null)
foreach (var i in localOptions.DisableLogTargets)
enabledTargets.Remove (i);
if (localOptions.DisableLogFile ?? false)
enabledTargets.Remove ("file");
}
// prepare log configuration
var config = new NLog.Config.LoggingConfiguration ();
// console output
if (!Console.IsOutputRedirected && enabledTargets.Contains ("console"))
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget ();
consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}";
config.AddTarget ("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule ("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add (rule1);
}
// file output
if (enabledTargets.Contains ("file"))
{
var fileTarget = new NLog.Targets.FileTarget ();
fileTarget.FileName = logFileName;
fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\"";
fileTarget.ConcurrentWrites = true;
fileTarget.ConcurrentWriteAttemptDelay = 10;
fileTarget.ConcurrentWriteAttempts = 8;
fileTarget.AutoFlush = true;
fileTarget.KeepFileOpen = true;
fileTarget.DeleteOldFileOnStartup = false;
fileTarget.ArchiveAboveSize = (localOptions.MaxLogFileSize > 0) ? localOptions.MaxLogFileSize : 4 * 1024 * 1024; // 4 Mb
fileTarget.MaxArchiveFiles = (localOptions.MaxArchiveLogFiles > 0) ? localOptions.MaxArchiveLogFiles : 10;
fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence;
fileTarget.ArchiveDateFormat = "yyyyMMdd";
fileTarget.ArchiveFileName = System.IO.Path.ChangeExtension (logFileName, ".{#}" + System.IO.Path.GetExtension (logFileName));
// set file output to be async (commented out since doesn't work well on mono)
// var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget);
config.AddTarget ("file", fileTarget);
// configure log from configuration file
var rule2 = new NLog.Config.LoggingRule ("*", currentLogLevel, fileTarget);
config.LoggingRules.Add (rule2);
}
// External Log Target
if (localOptions.Targets != null)
{
foreach (var t in localOptions.Targets)
{
if (GetNLogTargetName (t).Any (i => enabledTargets.Contains (i)))
{
config.AddTarget (t);
config.LoggingRules.Add (new NLog.Config.LoggingRule ("*", currentLogLevel, t));
}
}
}
// set configuration options
LogManager.Configuration = config;
}
/// <summary>
/// Creates the rule in the nlog manager with a given logger name and level
/// </summary>
/// <param name="loggerName">Name of the logger.</param>
/// <param name="level">The level.</param>
/// <returns></returns>
private static NLog.Config.LoggingRule CreateRule(string loggerName, NLog.LogLevel level)
{
NLog.Config.LoggingRule loggingRule = TryFindRule(loggerName);
// if it hasn't been created yet..
if (loggingRule == null)
{
loggingRule = new NLog.Config.LoggingRule();
loggingRule.LoggerNamePattern = loggerName;
foreach (NLog.Targets.Target target in NLog.LogManager.Configuration.ConfiguredNamedTargets)
{
loggingRule.Targets.Add(target);
}
NLog.LogManager.Configuration.LoggingRules.Add(loggingRule);
NLog.LogManager.ReconfigExistingLoggers();
}
return loggingRule;
}
protected void OnAction1Activated(object sender, EventArgs e)
{
TreeIter iter, imageiter;
//Создаем новый лог
if (RecognizeLog == null)
{
NLog.Config.LoggingConfiguration config = LogManager.Configuration;
RecognizeLog = new NLog.Targets.MemoryTarget();
RecognizeLog.Name = "recognizelog";
RecognizeLog.Layout = "${level} ${message}";
config.AddTarget("recognizelog", RecognizeLog);
NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule("*", LogLevel.Debug, RecognizeLog);
config.LoggingRules.Add(rule);
LogManager.Configuration = config;
}
else
RecognizeLog.Logs.Clear();
logger.Info("Запущен новый процесс распознования...");
if(!ImageList.GetIterFirst(out iter))
{
logger.Warn("Список изображений пуст. Остановка.");
return;
}
logger.Info("Всего документов: {0}", ImageList.IterNChildren());
progresswork.Text = "Распознование документов...";
progresswork.Adjustment.Upper = ImageList.IterNChildren();
MainClass.WaitRedraw();
do
{
if(ImageList.IterDepth(iter) == 0)
{
logger.Info((string) ImageList.GetValue(iter, 1));
Document doc = (Document) ImageList.GetValue(iter, 3);
if(doc == null)
{
logger.Warn("Тип не определён. Переходим к следующему...");
continue;
}
if(doc.Template == null)
{
logger.Warn("Шаблон распознования не указан. Переходим к следующему...");
continue;
}
int ImagesCount = ImageList.IterNChildren(iter);
Pixbuf[] Images = new Pixbuf[ImagesCount];
int i = 0;
ImageList.IterChildren(out imageiter, iter);
do
{
Images[i] = (Pixbuf) ImageList.GetValue(imageiter, 5);
i++;
}while(ImageList.IterNext(ref imageiter));
logger.Info("Тип: {0}", doc.TypeName);
logger.Info("Количество страниц: {0}", ImagesCount);
logger.Info("Инициализация движка...");
RecognizeDoc tess = new RecognizeDoc(doc, Images);
tess.DiagnosticMode = checkDiagnostic.Active;
//FIXME Для теста
tess.parent = this;
try
{
tess.Recognize();
}
catch (Exception ex)
{
QSMain.ErrorMessageWithLog (this, "Ошибка в модуле распознования!", logger, ex);
ShowLog();
}
ImageList.SetValue(iter, 8, GetDocIconByState(doc.State));
}
progresswork.Adjustment.Value++;
MainClass.WaitRedraw();
}while(ImageList.IterNext(ref iter));
logger.Info("Выполнено");
progresswork.Text = "Выполнено";
progresswork.Fraction = 0;
UpdateFieldsWidgets(true);
}
/// <summary>
/// Log initialization.
/// </summary>
internal static void InitializeLog(string logFileName = null, string logLevel = null)
{
// default parameters initialization from config file
if (String.IsNullOrEmpty(logFileName))
{
logFileName = System.Configuration.ConfigurationManager.AppSettings["logFilename"];
}
if (String.IsNullOrEmpty(logFileName))
{
logFileName = ("${basedir}/log/" + typeof(ConsoleUtils).Namespace.Replace(".SimpleHelpers", "") + ".log");
}
if (String.IsNullOrEmpty(logLevel))
{
logLevel = System.Configuration.ConfigurationManager.AppSettings["logLevel"] ?? "Info";
}
// check if log was initialized with same options
if (_logFileName == logFileName && _logLevel == logLevel)
{
return;
}
// save current log configuration
_logFileName = logFileName;
_logLevel = logLevel;
// try to parse loglevel
LogLevel currentLogLevel;
try { currentLogLevel = LogLevel.FromString(logLevel); }
catch { currentLogLevel = LogLevel.Info; }
// prepare log configuration
var config = new NLog.Config.LoggingConfiguration();
// console output
if (!Console.IsOutputRedirected)
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}";
config.AddTarget("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
}
// file output
var fileTarget = new NLog.Targets.FileTarget();
fileTarget.FileName = logFileName;
fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\"";
fileTarget.ConcurrentWrites = true;
fileTarget.AutoFlush = true;
fileTarget.KeepFileOpen = true;
fileTarget.DeleteOldFileOnStartup = false;
fileTarget.ArchiveAboveSize = 2 * 1024 * 1024; // 2 Mb
fileTarget.MaxArchiveFiles = 10;
fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.Date;
fileTarget.ArchiveDateFormat = "yyyyMMdd_HHmmss";
// set file output to be async (commented out since doesn't work on mono)
// var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget);
config.AddTarget("file", fileTarget);
// configure log from configuration file
var rule2 = new NLog.Config.LoggingRule("*", currentLogLevel, fileTarget);
config.LoggingRules.Add(rule2);
// set configuration options
LogManager.Configuration = config;
}
private static void SetupColorConsoleLogging()
{
var loggingConfig = NLog.LogManager.Configuration;
if (loggingConfig == null)
{
loggingConfig = new NLog.Config.LoggingConfiguration();
}
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
consoleTarget.Layout = "${longdate}:${message} ${exception:format=message,stacktrace=\r\n}";
loggingConfig.AddTarget("consoleTarget", consoleTarget);
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, consoleTarget);
loggingConfig.LoggingRules.Add(rule);
NLog.LogManager.Configuration = loggingConfig;
}
private void SetupLogging(ContainerBuilder builder)
{
builder.Register(context =>
{
if(_diMode != EnumDIMode.CommandLine)
{
//This resolve operation has already ended.
// When registering components using lambdas, the IComponentContext 'c' parameter to the lambda cannot be stored.
// Instead, either resolve IComponentContext again from 'c', or resolve a Func<> based factory to create subsequent components from.
var c = context.Resolve<IComponentContext>();
var identity = context.Resolve<IUserIdentity>();
var dbTarget = new NLogDBLogTarget(new AutofacDIFactory(c), identity);
dbTarget.Layout = "${message} ${exception:format=message,stacktrace:separator=\r\n}";
var loggingConfig = NLog.LogManager.Configuration;
if (loggingConfig == null)
{
loggingConfig = new NLog.Config.LoggingConfiguration();
}
loggingConfig.AddTarget("dbTarget", dbTarget);
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Warn, dbTarget);
loggingConfig.LoggingRules.Add(rule);
NLog.LogManager.Configuration = loggingConfig;
}
var logger = NLog.LogManager.GetCurrentClassLogger();
return logger;
})
.As<NLog.Logger>()
.SingleInstance();
Common.Logging.LogManager.Adapter = new Common.Logging.NLog.NLogLoggerFactoryAdapter((Common.Logging.Configuration.NameValueCollection)null);
builder.Register(ctx=>
{ return Common.Logging.LogManager.GetCurrentClassLogger(); })
.As<Common.Logging.ILog>()
.SingleInstance();
}
/// <summary>
/// Регистрируем правила Nlog для строки состояния
/// </summary>
/// <param name="methodName">Имя статического метода который будет вызываться при появлении сообщения.</param>
/// <param name="className">Имя класа в котором находится метод.</param>
public static void MakeNewStatusTargetForNlog(string methodName, string className)
{
NLog.Config.LoggingConfiguration config = LogManager.Configuration;
if (config.FindTargetByName ("status") != null)
return;
NLog.Targets.MethodCallTarget targetLog = new NLog.Targets.MethodCallTarget ();
targetLog.Name = "status";
targetLog.MethodName = methodName;
targetLog.ClassName = className;
targetLog.Parameters.Add (new NLog.Targets.MethodCallParameter ("${message}"));
config.AddTarget ("status", targetLog);
NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule ("*", targetLog);
rule.EnableLoggingForLevel (LogLevel.Info);
config.LoggingRules.Add (rule);
LogManager.Configuration = config;
}
