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 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;
}
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 void Setup(string logFilename)
{
var basePath = new FileInfo(typeof(NLogService).Assembly.Location).Directory.FullName;
var logPath = Path.Combine(basePath, "Log");
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
LoggerPath = Path.Combine(logPath, logFilename);
var config = new LoggingConfiguration();
var target = new NLog.Targets.DebuggerTarget();
config.AddTarget("file", target);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, target));
// TODO add better logger options
var fileTarget = new FileTarget {
FileName = LoggerPath
};
config.AddTarget("file", fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, fileTarget));
var console = new ColoredConsoleTarget();
config.AddTarget("file", console);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, console));
LogManager.Configuration = config;
}
private void ConfigureLogging()
{
var fileTarget = new FileTarget {
FileName = Path.Combine(GetLogFolder(), "log.xml"),
ArchiveFileName = "log_{#####}.xml",
ArchiveNumbering = ArchiveNumberingMode.Sequence,
ArchiveAboveSize = 1024*1024,
Layout = new Log4JXmlEventLayout()
};
var config = new LoggingConfiguration();
config.AddTarget("file", fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget));
var debuggerTarget = new DebuggerTarget();
config.AddTarget("debugger", debuggerTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, debuggerTarget));
if (Debugger.IsAttached) {
var udpTarget = new NetworkTarget {
Address = "udp4://localhost:962",
Layout = new Log4JXmlEventLayout()
};
config.AddTarget("udp", udpTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, udpTarget));
}
LogManager.Configuration = config;
PresentationTraceSources.DataBindingSource.Listeners.Add(new NLogTraceListener());
}
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 debugger target
var debuggerTarget = new DebuggerTarget();
debuggerTarget.Layout = layout;
config.AddTarget("console", debuggerTarget);
config.LoggingRules.Add(new LoggingRule("*", logLevel, WrapAsync(debuggerTarget)));
// create file target
var fileTarget = new FileTarget() { AutoFlush = false };
fileTarget.Layout = layout;
fileTarget.FileName = Path.Combine(this.directory, "BitSharp.log");
fileTarget.DeleteOldFileOnStartup = true;
config.AddTarget("file", fileTarget);
config.LoggingRules.Add(new LoggingRule("*", logLevel, WrapAsync(fileTarget)));
// activate configuration and bind
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 SetupLogging(LogLevel logLevel)
{
// Step 1. Create configuration object
var config = new LoggingConfiguration();
// Step 2. Create targets and add them to the configuration
var debuggerTarget = new DebuggerTarget();
config.AddTarget("debugger", debuggerTarget);
var fileTarget = new FileTarget();
config.AddTarget("file", fileTarget);
// Step 3. Set target properties
debuggerTarget.Layout = @"${logger:shortName=True} - ${uppercase:${level}}: ${message}";
fileTarget.FileName = "${specialfolder:folder=MyDocuments}/Artemis/logs/${shortdate}.txt";
fileTarget.Layout = "${longdate}|${level:uppercase=true}|${logger}|${message} ${exception:format=tostring}";
fileTarget.EnableFileDelete = true;
fileTarget.MaxArchiveFiles = 7;
fileTarget.ArchiveEvery = FileArchivePeriod.Minute;
// Step 4. Define rules
var rule1 = new LoggingRule("*", logLevel, debuggerTarget);
config.LoggingRules.Add(rule1);
var rule2 = new LoggingRule("*", logLevel, fileTarget);
config.LoggingRules.Add(rule2);
// Step 5. Activate the configuration
LogManager.Configuration = config;
// Log as fatal so it always shows
var logger = LogManager.GetCurrentClassLogger();
logger.Fatal("INFO: Set log level to {0}", logLevel);
}
private static Target CreateDebuggerTarget(LoggingConfiguration configuration)
{
var debuggerTarget = new DebuggerTarget();
configuration.AddTarget("debugger", debuggerTarget);
return debuggerTarget;
}
private void ConfigLogging()
{
var config = new LoggingConfiguration();
var target = new DebuggerTarget
{
Layout = @"${date:format=HH\\:MM\\:ss} ${logger} ${message}"
};
var sqlTarget = new FileTarget
{
Layout = @"${date:format=HH\\:MM\\:ss} ${logger} ${message}",
FileName = "sql.log"
};
var rule = new LoggingRule( "*", LogLevel.Trace, target );
var sqlRule = new LoggingRule( "NHibernate", LogLevel.Trace, sqlTarget );
config.AddTarget( "sql", sqlTarget );
config.AddTarget( "debugger", target );
config.LoggingRules.Add( sqlRule );
config.LoggingRules.Add( rule );
LogManager.Configuration = config;
}
private void InitializeLogger()
{
try
{
if (LogManager.Configuration != null)
{
return;
}
var target1 = new NLog.Targets.FileTarget();
target1.FileName = Path.Combine(GetTempFolder(), "Debug.log");
target1.KeepFileOpen = false;
target1.Layout = "${longdate}|${level:uppercase=true}|${logger}|${message}|${exception:format=ToString}";
var target2 = new NLog.Targets.DebuggerTarget();
LogManager.Configuration = new NLog.Config.LoggingConfiguration();
LogManager.Configuration.AddTarget("logFile", target1);
LogManager.Configuration.AddTarget("debug", target2);
LogManager.Configuration.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Trace, target1));
LogManager.Configuration.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Trace, target2));
LogManager.ReconfigExistingLoggers();
}
catch (Exception)
{
}
finally
{
logger = LogManager.GetCurrentClassLogger();
}
}
private void RegisterDebuggerTarget(IUnityContainer container)
{
var debuggerTarget = new DebuggerTarget()
{
Layout = Layout.FromString(Constants.Logging.DefaultLayout)
};
var rule1 = new LoggingRule("*", LogLevel.Debug, debuggerTarget);
container.RegisterInstance("Debugger", rule1);
}
private static void RegisterDebugger()
{
DebuggerTarget target = new DebuggerTarget();
target.Name = "debuggerLogger";
target.Layout = "[${level}] [${threadid}] ${logger}: ${message} ${onexception:inner=${newline}${newline}${exception:format=ToString}${newline}}";
var loggingRule = new LoggingRule("*", LogLevel.Trace, target);
LogManager.Configuration.AddTarget("debugger", target);
LogManager.Configuration.LoggingRules.Add(loggingRule);
}
static void Main(string[] args)
{
DebuggerTarget target = new DebuggerTarget();
target.Layout = "${message}";
NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug);
Logger logger = LogManager.GetLogger("Example");
logger.Debug("log message");
}
public static void Initialize()
{
#if DEBUG
var debugTarget = new DebuggerTarget() {
Name = "debug",
Layout = new SimpleLayout(@"${longdate} - ${level:uppercase=true}: ${message}${onexception:${newline}EXCEPTION\: ${exception:format=ToString}}"),
};
var debugRule = new LoggingRule("*", NLog.LogLevel.Info, debugTarget);
NLog.LogManager.Configuration.AddTarget("debug", debugTarget);
NLog.LogManager.Configuration.LoggingRules.Add(debugRule);
NLog.LogManager.ReconfigExistingLoggers();
#endif
}
public static void SetupLogger()
{
// IdentityServer uses LibLog, this means NLog is automatically detected.
// We just need to setup NLog and it will receive logmessages from IdentityServer
var loggingConfiguration = new LoggingConfiguration();
// Setup debugger target which logs to debugger, log statements will be visible in output window of Visual Studio
var debuggerTarget = new DebuggerTarget();
loggingConfiguration.AddTarget("DebuggerTarget", debuggerTarget);
loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, debuggerTarget));
LogManager.Configuration = loggingConfiguration;
LogManager.ThrowExceptions = true;
}
private static void ConfigureLogging()
{
var config = new LoggingConfiguration();
var fileTarget = new FileTarget {
FileName = Path.Combine(AppEnvironment.DataFolder, "log.txt")
};
config.AddTarget("file", fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget));
if (Debugger.IsAttached) {
var debuggerTarget = new DebuggerTarget();
config.AddTarget("debugger", debuggerTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, debuggerTarget));
}
LogManager.Configuration = config;
}
public static void Configure()
{
if (Configured) return;
var config = new LoggingConfiguration();
var console = new DebuggerTarget();
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, console));
LogManager.ThrowExceptions = true;
LogManager.Configuration = config;
var logger = LogManager.GetCurrentClassLogger();
logger.Info("Logging Configured!");
LoggingExtensions.Logging.Log.InitializeWith<LoggingExtensions.NLog.NLogLog>();
Configured = true;
}
public static void Initialize()
{
var reg = new ReactiveUI.NLog.Registrations();
reg.Register((f, t) => ((ModernDependencyResolver)RxApp.DependencyResolver).Register(f, t));
#if DEBUG
var debugTarget = new DebuggerTarget() {
Name = "debug",
Layout = new SimpleLayout(@"${longdate} - ${level:uppercase=true}: ${message}${onexception:${newline}EXCEPTION\: ${exception:format=ToString}}"),
};
var debugRule = new LoggingRule("*", NLog.LogLevel.Info, debugTarget);
NLog.LogManager.Configuration.AddTarget("debug", debugTarget);
NLog.LogManager.Configuration.LoggingRules.Add(debugRule);
NLog.LogManager.ReconfigExistingLoggers();
#endif
}
public static Logger BuildLogger()
{
var debuggerTarget = new DebuggerTarget
{
Layout = "${longdate} ${message} ${exception:format=tostring}",
};
var config = new LoggingConfiguration
{
LoggingRules =
{
new LoggingRule("*", LogLevel.Debug, debuggerTarget),
}
};
config.AddTarget("debug", debuggerTarget);
LogManager.Configuration = config;
return LogManager.GetLogger("");
}
public static void ConfigureNlog()
{
// Step 1. Create configuration object
var config = new LoggingConfiguration();
string callSight = "${callsite:className=false:fileName=true:includeSourcePath=false:methodName=true}";
// Step 2. Create targets and add them to the configuration
var debuggerTarget = new DebuggerTarget
{
Layout = callSight + "- ${logger}: ${message}"
};
var consoleTarget = new ColoredConsoleTarget
{
Layout = callSight + ": ${message}"
};
var fileTarget = new FileTarget
{
FileName = "${basedir}/test.log",
Layout = "${message}"
};
config.AddTarget("debugger", debuggerTarget);
config.AddTarget("console", consoleTarget);
//config.AddTarget("file", fileTarget);
// Step 3. Set target properties
// Step 4. Define rules
//LoggingRule fileRule = new LoggingRule("*", LogLevel.Trace, fileTarget);
LoggingRule debugRule = new LoggingRule("*", LogLevel.Trace, debuggerTarget);
LoggingRule consoleRule = new LoggingRule("*", LogLevel.Trace, consoleTarget);
//config.LoggingRules.Add(fileRule);
config.LoggingRules.Add(debugRule);
config.LoggingRules.Add(consoleRule);
// Step 5. Activate the configuration
LogManager.Configuration = config;
}
/// <summary>
/// Initializes a new instance of the <see cref="NoMorePanicSavePackage"/> class.
/// </summary>
public NoMorePanicSavePackage()
{
// Inside this method you can place any initialization code that does not require
// any Visual Studio service because at this point the package object is created but
// not sited yet inside Visual Studio environment. The place to do all the other
// initialization is the Initialize method.
#if DEBUG
this.logger = LogManager.GetLogger("NoMorePanicSave");
var configuration = new LoggingConfiguration();
var target = new DebuggerTarget();
configuration.AddTarget("console", target);
var rule = new LoggingRule("*", LogLevel.Trace, target);
configuration.LoggingRules.Add(rule);
this.logger.Factory.Configuration = configuration;
#else
this.logger = LogManager.CreateNullLogger();
#endif
}
public static void Setup()
{
var basePath = new FileInfo(typeof(MonoLogger).Assembly.Location).Directory.FullName;
var logPath = Path.Combine(basePath, "Log");
if (!Directory.Exists(logPath))
Directory.CreateDirectory(logPath);
LoggerPath = Path.Combine(logPath, "MonoRemoteDebugger.log");
var config = new LoggingConfiguration();
var target = new NLog.Targets.DebuggerTarget();
config.AddTarget("file", target);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, target));
var fileTarget = new FileTarget { FileName = LoggerPath };
config.AddTarget("file", fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, fileTarget));
var console = new ColoredConsoleTarget();
config.AddTarget("file", console);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, console));
LogManager.Configuration = config;
}
public static void ConfigureLogging(bool fullCaliburnMicroLogging = false)
{
ConfigurationItemFactory.Default.LayoutRenderers.RegisterDefinition("vslevel", typeof(VSLevelLayoutRenderer));
var config = new LoggingConfiguration();
var debugTarget = new DebuggerTarget();
debugTarget.Layout = "${logger} ${vslevel}: ${message}${onexception:inner=${newline}${exception:format=tostring}}";
config.AddTarget("debug", debugTarget);
// Quiet Caliburn.Micro
if (!fullCaliburnMicroLogging)
{
config.LoggingRules.Add(new LoggingRule("Screen", LogLevel.Warn, debugTarget) { Final = true });
config.LoggingRules.Add(new LoggingRule("Action", LogLevel.Warn, debugTarget) { Final = true });
config.LoggingRules.Add(new LoggingRule("ViewModelBinder", LogLevel.Warn, debugTarget) { Final = true });
}
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, debugTarget));
NLogManager.Configuration = config;
CMLogManager.GetLog = type => new CaliburnMicroNLogShim(type);
}
static void ConfigureNLog()
{
string outputLayout = "[${time}-${level}] ${logger} >> ${message}";
LoggingConfiguration config = new LoggingConfiguration();
ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget();
consoleTarget.Layout = outputLayout;
config.AddTarget("console", consoleTarget);
DebuggerTarget debuggerTarget = new DebuggerTarget();
debuggerTarget.Layout = outputLayout;
config.AddTarget("debugger", debuggerTarget);
LoggingRule ruleConsole = new LoggingRule("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(ruleConsole);
LoggingRule ruleDebugger = new LoggingRule("*", LogLevel.Trace, debuggerTarget);
config.LoggingRules.Add(ruleDebugger);
LogManager.Configuration = config;
}
public static void Setup()
{
var codeBase = Assembly.GetExecutingAssembly().CodeBase ?? Assembly.GetEntryAssembly().CodeBase;
var basePath = new FileInfo(new Uri(codeBase).LocalPath).Directory.FullName;
var logPath = Path.Combine(basePath, "Log");
if (!Directory.Exists(logPath))
{
Directory.CreateDirectory(logPath);
}
LoggerPath = Path.Combine(logPath, "MonoTools.Debugger.log");
var config = new LoggingConfiguration();
var target = new NLog.Targets.DebuggerTarget();
target.Layout = new NLog.Layouts.SimpleLayout("${message}");
config.AddTarget("file", target);
#if DEBUG
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, target));
#else
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, target));
#endif
var fileTarget = new FileTarget {
FileName = LoggerPath
};
config.AddTarget("file", fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, fileTarget));
var console = new ColoredConsoleTarget();
console.Layout = new NLog.Layouts.SimpleLayout("${message}");
config.AddTarget("file", console);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, console));
LogManager.Configuration = config;
}
private static void ConfigureLogging(string logFileName)
{
var fileTarget = new FileTarget {
FileName = logFileName,
Header = new SimpleLayout("${longdate} ----------------------------------------${newline}${longdate} - Process ${processname:fullName=true}"),
Layout = new SimpleLayout("${longdate} - ${message} ${exception:format=tostring}")
};
var asyncTarget = new AsyncTargetWrapper(fileTarget);
var config = new LoggingConfiguration();
config.AddTarget("file", asyncTarget);
var rule1 = new LoggingRule("*", LogLevel.Debug, asyncTarget);
config.LoggingRules.Add(rule1);
if (Debugger.IsAttached) {
var debuggerTarget = new DebuggerTarget {
Layout = new SimpleLayout("${logger}: ${level:uppercase=true} ${message}${onexception:inner=${newline}${exception:format=tostring:maxInnerExceptionLevel=10}}")
};
config.AddTarget("debugger", debuggerTarget);
var rule2 = new LoggingRule("*", LogLevel.Debug, debuggerTarget);
config.LoggingRules.Add(rule2);
}
LogManager.Configuration = config;
}
/// <summary> Logs all levels to attached managed debugger (e.g. Visual Studio output window) </summary>
public LoggerConfiguration AddDebuggerTarget(LogLevel minLogLevel, string layout = null)
{
var target = new DebuggerTarget { Layout = layout ?? StandardLayout };
return this.AddTarget(minLogLevel, target);
}
/// <summary>
/// Default initialization for on-premise paths
/// </summary>
private void InitializeForPremise()
{
// Replace log file and role name settings in the configuration
var currentCfg = LogManager.Configuration;
if (currentCfg == null)
{
Trace.WriteLine("No on-premise NLog configuration available - creating default config");
var level = LogLevel.Debug;
var config = new LoggingConfiguration();
var console = new ColoredConsoleTarget
{
UseDefaultRowHighlightingRules = true,
Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"
};
var file = new FileTarget
{
FileName = "${basedir}/application.log",
Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"
};
var debug = new DebuggerTarget
{
Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"
};
config.AddTarget("debug", debug);
config.AddTarget("console", console);
config.AddTarget("file", file);
config.LoggingRules.Add(new LoggingRule("*", level, console));
config.LoggingRules.Add(new LoggingRule("*", level, file));
config.LoggingRules.Add(new LoggingRule("*", level, debug));
LogManager.Configuration = config;
}
else
{
Trace.WriteLine("Using NLog.config for non-Azure deployment");
}
}
