[STAThread] // for file dialog boxes
static void Main(string[] args)
{
var config = new NLog.Config.LoggingConfiguration();
var easyToReadLog = "${level:uppercase=true}: ${message}";
var rtbTarget = new NLog.Windows.Forms.RichTextBoxTarget(); // garbage documentation from NLog - need nuget Nlog and Nlog.windows.forms
rtbTarget.TargetForm = gui;
rtbTarget.TargetRichTextBox = gui.logBox;
rtbTarget.UseDefaultRowColoringRules = true;
rtbTarget.Layout = easyToReadLog;
// Targets where to log to: File and Console
var logfile = new NLog.Targets.FileTarget("logfile")
{
FileName = "log.txt"
};
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
logconsole.Layout = easyToReadLog;
logconsole.UseDefaultRowHighlightingRules = true;
logfile.Layout = "${longdate} |" + easyToReadLog;
// Rules for mapping loggers to targets
config.AddRule(LogLevel.Info, LogLevel.Fatal, logconsole);
config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile);
config.AddRule(LogLevel.Info, LogLevel.Fatal, rtbTarget);
NLog.LogManager.Configuration = config;
log.Info("Program started");
gui.ShowDialog();
}
private static void ConfigureLogging()
{
var logConfig = new NLog.Config.LoggingConfiguration();
// Targets where to log to: File and Console
string logLayout = "${longdate}|${level:uppercase=true}|${logger}|${threadid}|${message}|${onexception:inner=${newline}${exception:format=toString}}";
var logFile = new NLog.Targets.FileTarget("logfile")
{
Layout = logLayout,
FileName = "output.log",
ArchiveEvery = NLog.Targets.FileArchivePeriod.Day,
MaxArchiveFiles = 30,
ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence,
ArchiveAboveSize = 512 * 1024, // 512 KB
};
var logConsole = new NLog.Targets.ColoredConsoleTarget("logconsole")
{
Layout = logLayout,
};
// Rules for mapping loggers to targets
logConfig.AddRule(LogLevel.Info, LogLevel.Fatal, logConsole);
logConfig.AddRule(LogLevel.Debug, LogLevel.Fatal, logFile);
// Apply config
LogManager.Configuration = logConfig;
}
private static void SetupLogger()
{
var config = new NLog.Config.LoggingConfiguration();
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
var layout = new NLog.Layouts.SimpleLayout(
"[${date:format=HH\\:mm\\:ss}][${level}]${logger:shortName=true}: ${message}"
);
logconsole.Layout = layout;
logconsole.Encoding = System.Text.Encoding.UTF8;
var logfile = new NLog.Targets.FileTarget("logfile");
logfile.FileName = "./logs/log.txt";
logfile.ArchiveFileName = "log.{#}.txt";
logfile.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.Date;
logfile.ArchiveDateFormat = "dd-MM-yyyy";
logfile.ArchiveEvery = NLog.Targets.FileArchivePeriod.Day;
logfile.CreateDirs = true;
logfile.Layout = layout;
logfile.Encoding = System.Text.Encoding.UTF8;
config.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Fatal, logconsole, "*");
config.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, logfile, "*");
NLog.LogManager.Configuration = config;
logger = NLog.LogManager.GetCurrentClassLogger();
}
/// <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;
}
/// <summary>
/// Register the
/// </summary>
private NLogAudit(AuditType minType, AuditTarget[] targets)
{
var config = new NLog.Config.LoggingConfiguration();
var minLevel = Translate(minType);
foreach (var t in targets)
{
NLog.Targets.Target target = null;
switch (t)
{
case AuditTarget.Console:
target = new NLog.Targets.ColoredConsoleTarget("console");
break;
case AuditTarget.File:
target = new NLog.Targets.FileTarget("logfile")
{
FileName = GetDefaultLogFileName()
};
break;
case AuditTarget.Db:
default:
throw new NotImplementedException($"Audit target {t}");
}
config.AddRule(minLevel, NLog.LogLevel.Fatal, target);
}
NLog.LogManager.Configuration = config;
logger = NLog.LogManager.GetCurrentClassLogger();
Audit.Register(this);
}
public static void ConfigureLog(string logfilePath, string eventfilePath, bool eventToConsole = false)
{
var config = new NLog.Config.LoggingConfiguration();
var logfile = new NLog.Targets.FileTarget(DistanceOutputLoggerName)
{
FileName = logfilePath
};
config.AddRule(LogLevel.Info, LogLevel.Fatal, logfile, DistanceOutputLoggerName);
var evtfile = new NLog.Targets.FileTarget(DistanceOutputLoggerName)
{
FileName = eventfilePath
};
config.AddRule(LogLevel.Info, LogLevel.Fatal, evtfile, DistanceEventLoggerName);
var logconsole = new NLog.Targets.ColoredConsoleTarget(DistanceEventLoggerName);
if (eventToConsole)
{
config.AddRule(LogLevel.Warn, LogLevel.Fatal, logconsole, DistanceEventLoggerName);
}
LogManager.Configuration = config;
m_logger = LogManager.GetLogger(DistanceOutputLoggerName);
m_eventLogger = LogManager.GetLogger(DistanceEventLoggerName);
}
public static void init_logging(logConfig userConfig)
{
// Logging
var config = new NLog.Config.LoggingConfiguration();
// Targets where to log to: File and Console
//var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "file.txt" };
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
LogLevel userLogLevel = LogLevel.Info;
if (userConfig.logLevel.ToLower() == "debug")
{
userLogLevel = LogLevel.Debug;
}
if (userConfig.logLevel.ToLower() == "warning")
{
userLogLevel = LogLevel.Warn;
}
if (userConfig.logLevel.ToLower() == "error")
{
userLogLevel = LogLevel.Error;
}
if (userConfig.logLevel.ToLower() == "fatal")
{
userLogLevel = LogLevel.Fatal;
}
// Rules for mapping loggers to targets
config.AddRule(userLogLevel, LogLevel.Fatal, logconsole);
// Apply config
NLog.LogManager.Configuration = config;
}
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 -------");
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
//Log
var logConfig = new NLog.Config.LoggingConfiguration();
var fileTarget = new NLog.Targets.FileTarget();
fileTarget.FileName = Configuration["Data:Log:logFile"];
fileTarget.Name = "FileLogger";
fileTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger}:${message};${exception}";
logConfig.AddTarget(fileTarget);
logConfig.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget));
if (env.IsDevelopment())
{
var consoleLogger = new NLog.Targets.ColoredConsoleTarget();
consoleLogger.Name = "ConsoleLogger";
consoleLogger.Layout = @"${date:format=HH\:mm\:ss} ${logger}:${message};${exception}";
logConfig.AddTarget(consoleLogger);
logConfig.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, consoleLogger));
}
LogManager.Configuration = logConfig;
// Add the platform handler to the request pipeline.
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
LogManager.GetLogger("Website").Info("Started!");
}
public opcProducerTest()
{
var log = new NLog.Config.LoggingConfiguration();
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
// Rules for mapping loggers to targets
log.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole);
// Apply config
NLog.LogManager.Configuration = log;
kafkaProducerConf conf = new kafkaProducerConf()
{
MessageSendMaxRetries = 100,
BatchNumMessages = 23,
QueueBufferingMaxKbytes = 100,
QueueBufferingMaxMessages = 32,
MessageTimeoutMs = 10000,
LingerMs = 200
};
// schema registry
var registry = new CachedSchemaRegistryClient(new SchemaRegistryConfig()
{
Url = "localhost:8081",
ValueSubjectNameStrategy = SubjectNameStrategy.TopicRecord
});
kafka = new opcKafkaProducer(conf, registry);
schemas = new opcSchemas();
}
static int Main(string[] args)
{
// Configure NLog
var config = new NLog.Config.LoggingConfiguration();
var console = new NLog.Targets.ColoredConsoleTarget()
{
Layout = "${message}"
};
config.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, console);
NLog.LogManager.Configuration = config;
var logger = NLog.LogManager.GetCurrentClassLogger();
logger.Info($"MergeMediaFoldersConsole v{Version}");
// Parse command line options and execute the request
int returnCode = 0;
if (args.Length == 0)
{
logger.Error("Required command line arguments were missing.");
returnCode = 2;
}
else
{
returnCode = Parser.Default.ParseArguments <MergeOptions>(args)
.MapResult(
(MergeOptions opts) => {
if (opts.Verbose)
{
config.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Debug, console);
}
opts.LogArguments();
return(new MergeAction(opts).MergeAndReturnExitCode());
},
errs =>
{
foreach (var e in errs)
{
logger.Error("Unable to parse command line arguments.");
logger.Error(e);
}
return(1);
}
);
}
// Catch the end of the program in the debugger.
if (System.Diagnostics.Debugger.IsAttached)
{
Console.WriteLine($"Exit code: {returnCode}");
Console.Write("Press any key to end.");
Console.Read();
}
return(returnCode);
}
public static void SetLogConf()
{
var config = new NLog.Config.LoggingConfiguration();
var console = new NLog.Targets.ColoredConsoleTarget("console");
config.AddRule(LOG_LEVEL, LogLevel.Fatal, console);
NLog.LogManager.Configuration = config;
}
private static void RegisterLogger(IUnityContainer container)
{
var config = new NLog.Config.LoggingConfiguration();
var logConsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
config.AddRule(LogLevel.Trace, LogLevel.Fatal, logConsole);
LogManager.Configuration = config;
ILogger logger = NLog.LogManager.GetCurrentClassLogger();
container.RegisterInstance <ILogger>(logger);
}
private static void InitLoggers()
{
var config = new NLog.Config.LoggingConfiguration();
var target = new NLog.Targets.ColoredConsoleTarget();
config.AddTarget("logfile", target);
config.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Info, target));
NLog.LogManager.Configuration = config;
}
public static void SetLoggerConfigurationManually()
{
var config = new NLog.Config.LoggingConfiguration();
// Создадим Targets для async обёртки
var logRequests = new NLog.Targets.FileTarget("logRequests");
logRequests.FileName = "${basedir}/logs/httpRequests.txt";
logRequests.ArchiveFileName = "${basedir}/logs/archive/httpRequests.{####}.txt";
logRequests.ArchiveAboveSize = 10000240;
var logTroubles = new NLog.Targets.FileTarget("logTroubles");
logTroubles.FileName = "${basedir}/logs/troubles.txt";
logTroubles.ArchiveFileName = "${basedir}/logs/archive/troubles.{####}.txt";
logTroubles.ArchiveAboveSize = 10240;
var logConsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
logConsole.UseDefaultRowHighlightingRules = true;
var logDirectoryEvents = new NLog.Targets.FileTarget("logDirectoryEvents");
logTroubles.FileName = "${basedir}/logs/directoryEvents.txt";
logTroubles.ArchiveFileName = "${basedir}/logs/archive/directoryEvents.{####}.txt";
logTroubles.ArchiveAboveSize = 10240;
// Создадим обёртки для асинхронных записей
var asyncTargetWrapper1 = new NLog.Targets.Wrappers.AsyncTargetWrapper(logRequests);
var asyncTargetWrapper2 = new NLog.Targets.Wrappers.AsyncTargetWrapper(logTroubles);
var asyncTargetWrapper3 = new NLog.Targets.Wrappers.AsyncTargetWrapper(logConsole);
var asyncTargetWrapper4 = new NLog.Targets.Wrappers.AsyncTargetWrapper(logDirectoryEvents);
// Создадим sync targets
var logBigTroubles = new NLog.Targets.FileTarget("logBigTroubles");
logBigTroubles.FileName = "${basedir}/logs/bigTroubles.txt";
logBigTroubles.ArchiveFileName = "${basedir}/logs/archive/bigTroubles.{####}.txt";
logBigTroubles.ArchiveAboveSize = 10240;
// Зададим Rules
config.AddRuleForOneLevel(LogLevel.Error, logBigTroubles);
config.AddRuleForOneLevel(LogLevel.Warn, logTroubles);
config.AddRuleForOneLevel(LogLevel.Info, logRequests);
config.AddRuleForOneLevel(LogLevel.Debug, logConsole);
config.AddRuleForOneLevel(LogLevel.Trace, logDirectoryEvents);
// Применим Configuration
NLog.LogManager.Configuration = config;
}
private static NLog.Logger InitNlog()
{
var config = new NLog.Config.LoggingConfiguration();
var consoleTarget = new NLog.Targets.ColoredConsoleTarget("consoleTarget")
{
Layout = @"${longdate} ${level} ${message} ${exception}"
};
config.AddTarget(consoleTarget);
config.AddRule(NLog.LogLevel.FromString(Instance.Nlog.LogLevel), NLog.LogLevel.Fatal, consoleTarget);
NLog.LogManager.Configuration = config;
return(NLog.LogManager.GetCurrentClassLogger());
}
private static void ConfigLogger()
{
var config = new LoggingConfiguration();
var target = new NLog.Targets.ColoredConsoleTarget("logconsole")
{
Layout = "${longdate}|${level:uppercase=true}|${message}",
UseDefaultRowHighlightingRules = true
};
// Rules for mapping loggers to targets
config.AddRule(LogLevel.Trace, LogLevel.Fatal, target);
// Apply config
LogManager.Configuration = config;
}
/// <summary>
/// Configures the logging of the application.
/// </summary>
private static void ConfigureLogging(Options options)
{
if (options == null)
{
throw new System.ArgumentNullException("options");
}
if (LogManager.Configuration != null)
{
return;
}
var config = new LoggingConfiguration();
// add console logging
if (options.LogConsole)
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget()
{
Name = "console",
Layout = "${message}",
};
config.AddTarget(consoleTarget);
config.LoggingRules.Add(new LoggingRule("SqsWorker*", LogLevel.Info, consoleTarget));
}
// add file logging
if (options.Log)
{
var fileTarget = new NLog.Targets.FileTarget()
{
Name = "file",
Layout = "${longdate} ${logger} ${message}",
FileName = options.LogFile,
ArchiveFileName = options.LogArchiveFile,
ArchiveEvery = NLog.Targets.FileArchivePeriod.Day,
ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.Rolling,
ArchiveAboveSize = 5242880,
ConcurrentWrites = true,
MaxArchiveFiles = 5,
KeepFileOpen = false,
Encoding = Encoding.UTF8,
};
config.AddTarget(fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.FromString(options.LogLevel), fileTarget));
}
LogManager.Configuration = config;
}
public static void init_logging()
{
// Logging
var config = new NLog.Config.LoggingConfiguration();
// Targets where to log to: File and Console
//var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "file.txt" };
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
// Rules for mapping loggers to targets
config.AddRule(LogLevel.Info, LogLevel.Fatal, logconsole);
//config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole);
// Apply config
NLog.LogManager.Configuration = config;
}
private static void Main(string[] args)
{
LogManager.GlobalThreshold = LogLevel.Debug;
AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper;
AppDomain.CurrentDomain.FirstChanceException += ExceptionTrapper;
ServicePointManager.UseNagleAlgorithm = false;
var conf = NLog.Config.ConfigurationItemFactory.Default;
var logging = new NLog.Config.LoggingConfiguration();
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
consoleTarget.Layout = "${date:universalTime=true:format=yyyy-MM-dd HH:mm:ss.fff} ${level:padding=-5:uppercase=true} ${logger:padding=-20:fixedLength=true} - ${message}";
logging.AddTarget("console", consoleTarget);
logging.AddRule(LogLevel.Debug, LogLevel.Fatal, consoleTarget);
LogManager.Configuration = logging;
NServiceBus.Logging.LogManager.Use <NLogFactory>();
//EventStore.Common.Log.LogManager.SetLogFactory((name) => new EmbeddedLogger(name));
_container = new StructureMap.Container(x =>
{
x.Scan(y =>
{
y.TheCallingAssembly();
y.WithDefaultConventions();
});
});
var bus = InitBus().Result;
Console.WriteLine("Press CTRL+C to exit...");
Console.CancelKeyPress += (sender, eArgs) =>
{
QuitEvent.Set();
eArgs.Cancel = true;
};
QuitEvent.WaitOne();
bus.Stop().Wait();
}
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 SetupLogger()
{
var config = new NLog.Config.LoggingConfiguration();
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
var layout = new NLog.Layouts.SimpleLayout(
"[${date:format=HH\\:mm\\:ss}][${level}]${logger:shortName=true}: ${message}"
);
logconsole.Layout = layout;
logconsole.Encoding = System.Text.Encoding.UTF8;
config.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, logconsole, "*");
NLog.LogManager.Configuration = config;
logger = NLog.LogManager.GetCurrentClassLogger();
}
public opcKafkaRPCTest()
{
var log = new NLog.Config.LoggingConfiguration();
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
// Rules for mapping loggers to targets
log.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole);
// Apply config
NLog.LogManager.Configuration = log;
// schema registry
registry = new CachedSchemaRegistryClient(new SchemaRegistryConfig()
{
Url = "localhost:8081",
ValueSubjectNameStrategy = SubjectNameStrategy.TopicRecord
});
// default configuration
rpc = new opcKafkaRPC(new kafkaRPCConf(), registry);
cancel = new CancellationTokenSource();
schemas = new opcSchemas();
producer = new ProducerBuilder <String, GenericRecord>(new kafkaProducerConf().getProducerConf())
.SetValueSerializer(new AvroSerializer <GenericRecord>(registry))
.Build();
req = new GenericRecord(schemas.rpcRequest);
req.Add("method", "write");
req.Add("params", new string[] { "ciao", "bella" });
req.Add("id", 89);
var cnf = new kafkaRPCConf().getConsumerConf();
cnf.AutoOffsetReset = AutoOffsetReset.Earliest;
// this is necessary otherwise fail because of rebalancing, send messages to dead consumer
cnf.GroupId = "test-never-give-this-id-" + DateTime.Now.Millisecond.ToString();
Console.WriteLine("using group id: " + "test-never-give-this-id-" + DateTime.Now.Millisecond.ToString());
consumer = new ConsumerBuilder <String, GenericRecord>(cnf)
.SetValueDeserializer(new AvroDeserializer <GenericRecord>(registry).AsSyncOverAsync())
.Build();
consumer.Subscribe("OPC-response");
}
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;
}
private void _ConfigureLogger()
{
var config = new NLog.Config.LoggingConfiguration();
// Targets where to log to: File and Console
var logfile = new NLog.Targets.FileTarget("logfile")
{
FileName = Path.Combine(Utils.GetDefaultDataDirectory(), "SnapDotNet.log")
};
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
// Rules for mapping loggers to targets
config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole);
config.AddRule(LogLevel.Info, LogLevel.Fatal, logfile);
// Apply config
NLog.LogManager.Configuration = config;
}
public static Logger CreateNlog(IConfiguration configuration)
{
//var seqServerUrl = configuration["Serilog:SeqServerUrl"];
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole");
var config = new LoggingConfiguration()
{
};
config.AddRule(LogLevel.Off, loggerNamePattern: "Microsoft.AspNetCore.SignalR", final: true, target: logconsole, maxLevel: LogLevel.Debug);
config.AddRule(LogLevel.Off, loggerNamePattern: "Microsoft.AspNetCore.Http.Connections", final: true, target: logconsole, maxLevel: LogLevel.Debug);
config.AddRule(LogLevel.Off, loggerNamePattern: "Microsoft.*", final: true, target: logconsole, maxLevel: LogLevel.Info);
config.AddRule(LogLevel.Off, LogLevel.Trace, logconsole, loggerNamePattern: "*");
//NLog.Web.NLogBuilder.ConfigureNLog(config);
var logger = NLog.Web.NLogBuilder.ConfigureNLog("nlog.config").GetCurrentClassLogger();
logger.Log(LogLevel.Debug, "init logger");
return(logger);
}
private static void ConfigureLogging(bool isDebug, bool isWhatIf)
{
var config = new NLog.Config.LoggingConfiguration();
var logInConsoleTarget = new NLog.Targets.ColoredConsoleTarget("logConsoleTarget")
{
Layout = new SimpleLayout("${message}")
};
var logInFileTarget = new NLog.Targets.FileTarget("logFileTarget")
{
FileName = "${baseDir}\\logs\\${shortdate}.log",
Layout = new SimpleLayout("${longdate} [${level}] [${callsite}]: ${message}")
};
config.AddRule(isDebug || isWhatIf ? LogLevel.Trace : LogLevel.Info, LogLevel.Fatal, logInConsoleTarget);
config.AddRule(isDebug ? LogLevel.Trace : LogLevel.Off, LogLevel.Fatal, logInFileTarget);
LogManager.Configuration = config;
}
public static void SetConfiguration(NLog.LogLevel logLevel)
{
var config = new NLog.Config.LoggingConfiguration();
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
consoleTarget.UseDefaultRowHighlightingRules = false;
consoleTarget.RowHighlightingRules.Add(
new NLog.Targets.ConsoleRowHighlightingRule(
"level == LogLevel.Fatal",
NLog.Targets.ConsoleOutputColor.Magenta,
NLog.Targets.ConsoleOutputColor.NoChange));
consoleTarget.RowHighlightingRules.Add(
new NLog.Targets.ConsoleRowHighlightingRule(
"level == LogLevel.Error",
NLog.Targets.ConsoleOutputColor.Red,
NLog.Targets.ConsoleOutputColor.NoChange));
consoleTarget.RowHighlightingRules.Add(
new NLog.Targets.ConsoleRowHighlightingRule(
"level == LogLevel.Warn",
NLog.Targets.ConsoleOutputColor.Yellow,
NLog.Targets.ConsoleOutputColor.NoChange));
consoleTarget.RowHighlightingRules.Add(
new NLog.Targets.ConsoleRowHighlightingRule(
"level == LogLevel.Info",
NLog.Targets.ConsoleOutputColor.Gray,
NLog.Targets.ConsoleOutputColor.NoChange));
consoleTarget.RowHighlightingRules.Add(
new NLog.Targets.ConsoleRowHighlightingRule(
"level == LogLevel.Debug",
NLog.Targets.ConsoleOutputColor.Gray,
NLog.Targets.ConsoleOutputColor.DarkGray));
consoleTarget.RowHighlightingRules.Add(
new NLog.Targets.ConsoleRowHighlightingRule(
"level == LogLevel.Trace",
NLog.Targets.ConsoleOutputColor.DarkGray,
NLog.Targets.ConsoleOutputColor.Gray));
consoleTarget.Layout = @"${message}${onexception:${newline}${exception:format=tostring}}";
config.AddTarget("console", consoleTarget);
config.LoggingRules.Add(new NLog.Config.LoggingRule("*", logLevel, consoleTarget));
NLog.LogManager.Configuration = config;
}
/// <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;
}
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 void ConfigureLogger()
{
var config = new NLog.Config.LoggingConfiguration();
var logConsole = new NLog.Targets.ColoredConsoleTarget("logconsole")
{
Layout = Layout.FromString(
"${time} | <${logger:shortName=true}> [${level:uppercase=true}]: ${message} ${exception:format=tostring}")
};
var logFile = new NLog.Targets.FileTarget("logfile")
{
FileName = "log.log",
Layout = Layout.FromString(
"${time} | <${logger}> [${level:uppercase=true}]: ${message} ${exception:format=tostring}")
};
config.AddRule(LogLevel.Trace, LogLevel.Fatal, logConsole);
config.AddRule(LogLevel.Info, LogLevel.Fatal, logFile);
NLog.LogManager.Configuration = config;
}
public static void Config()
{
var config = new NLog.Config.LoggingConfiguration();
// Targets where to log to: File and Console
var logfile = new NLog.Targets.FileTarget("logfile")
{
FileName = "file.txt",
Layout = "${longdate} ${uppercase:${level}} ${message} ${exception:format=Message,StackTrace,Data:maxInnerExceptionLevel=10}",
};
var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole")
{
Layout = "${longdate} ${uppercase:${level}} ${message} ${exception:format=Message,StackTrace,Data:maxInnerExceptionLevel=10}",
};
// Rules for mapping loggers to targets
config.AddRuleForAllLevels(logconsole);
config.AddRuleForAllLevels(logfile);
// Apply config
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;
}
/// <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;
}
public static void Main(string[] args)
{
var configuration = new LoggingConfiguration();
var target = new NLog.Targets.ColoredConsoleTarget { Layout = new SimpleLayout("${message}") };
configuration.AddTarget("ColoredConsoleTarget", target);
configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, target));
LogManager.Configuration = configuration;
var log = LogManager.GetLogger("Program");
log.Info("Loading xml dump...");
var content = WikiImporter.Import("pages.xml");
log.Info("Compiling and publishing...");
var publisher = new EpubPublisher();
publisher.Publish(content, string.Format("{0}.epub", content.Title));
// var parser = new WikiMarkupParser();
// const string text = @"== Mass Effect ==
//=== Paragon ===
//[[Image:ME1 Paragon.png|right|150px]]
//Paragon points are gained for compassionate and heroic actions. The Paragon measurement is colored blue. Points are often gained when asking about feelings and motivations of characters.
//Paragon or Charm dialogue choices (colored blue in dialogue trees) often lead to people being more open and friendly with Shepard,
//and can sometimes avert entire battles that would otherwise be triggered.
//
//Shepard starts the game with 3 open Charm ranks. The Paragon scale affects Charm and more as defined below:
//:10% – Opens 2 Charm ranks. Gives 1 Charm point.
//:25% – Opens 2 Charm ranks. Gives 1 Charm point. Bonus: 10% shorter [[First Aid]] cooldown.
//:50% – No charm ranks/points. Bonus: 10% maximum [[health]].
//:75% – Opens 2 Charm ranks. Gives 1 Charm point. Bonus: 5% reduction in cooldown on all powers. [[Achievement]].
//
//After reaching 80% Paragon points, [[Admiral Hackett]] will give Shepard the [[UNC: Besieged Base]] assignment.
//
//The ""free"" bonus skill points can be gained again if importing the character for another playthrough.
//
//=== Renegade ===
//[[Image:ME1 Renegade.png|right|150px]]
//Renegade points are gained for apathetic and ruthless actions. The Renegade measurement is colored red. Many sarcastic and joking remarks are assigned Renegade points.
//Renegade or Intimidate dialogue choices (colored red in dialogue trees) generally lead to people disliking and even fearing Shepard,
//and occasionally ""encourage"" people to tell or give more than they otherwise would. Like with Paragon/Charm options, Shepard can sometimes avert entire battles that would otherwise be triggered.
//
//Shepard starts with 3 open Intimidate ranks. The Renegade scale affects Intimidate and more as defined below:
//:10% – Opens 2 Intimidate ranks, gives 1 Intimidate point.
//:25% – Opens 2 Intimidate ranks, gives 1 Intimidate point, 10% reduction in weapon powers cooldown.
//:50% – 1 health regeneration per second.
//:75% – Achievement, opens 2 Intimidate ranks, gives 1 Intimidate point, 5% increase in damage/duration on all weapons and powers
//
//After reaching 80% Renegade points, [[Admiral Hackett]] will give Shepard the [[UNC: The Negotiation]] assignment.
//
//The ""free"" bonus skill points can be gained again if importing the character for another playthrough.
//{{Spoilers (Mass Effect)}}
//
//=== Spectre Bonus ===
//Becoming a [[Spectre]] in Mass Effect opens 3 more ranks and gives 1 skill point in both Charm and Intimidate.";
// var node = parser.Parse("Paragon", text);
// var compiler = new HtmlCompiler(new HtmlResourceManagerStub(), new CssStyleManagerStub());
// var doc = compiler.Compile(node);
// Console.WriteLine(doc.ToString());
// Console.ReadKey();
}
/// <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;
}
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;
}
