public override void Load()
{
// log layout format
var layout = "${pad:padding=6:inner=${level:uppercase=true}} ${message} ${exception:separator=\r\n:format=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;
this.Kernel.Bind <Logger>().ToMethod(context => LogManager.GetLogger("BitSharp"));
}
private void ConfigureLogging()
{
var config = new LoggingConfiguration();
var fileTarget = new FileTarget
{
Layout = "${longdate} [${level:uppercase=true}] ${logger}: ${message} ${exception}",
FileName = "log.txt",
DeleteOldFileOnStartup = true
};
config.AddTarget("Logfile", fileTarget);
var fileRule = new LoggingRule("*", LogLevel.Trace, fileTarget);
config.LoggingRules.Add(fileRule);
// Don't bother with logging something to a debugger in release mode
if (Constants.Debug)
{
var debuggerTarget = new DebuggerTarget
{
Layout = "[${level:uppercase=true}] ${logger}: ${message} ${exception}"
};
config.AddTarget("debugger", debuggerTarget);
var debuggerRule = new LoggingRule("*", LogLevel.Trace, debuggerTarget);
config.LoggingRules.Add(debuggerRule);
}
LogManager.Configuration = config;
}
public static void Configure(LogLevel logLevel = null)
{
logLevel = logLevel ?? LogLevel.Info;
// 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 = LogManager.Configuration ?? new LoggingConfiguration();
// create console target
if (!Debugger.IsAttached)
{
var consoleTarget = new ColoredConsoleTarget();
consoleTarget.Layout = layout;
config.AddTarget("console", consoleTarget);
config.LoggingRules.Add(new LoggingRule("*", logLevel, consoleTarget));
}
else
{
var consoleTarget = new DebuggerTarget();
consoleTarget.Layout = layout;
config.AddTarget("console", consoleTarget);
config.LoggingRules.Add(new LoggingRule("*", logLevel, consoleTarget));
}
// activate configuration and bind
LogManager.Configuration = config;
}
public static void AssemblyInit(TestContext context)
{
var config = new LoggingConfiguration();
var debuggerTarget = new DebuggerTarget("debugger")
{
Layout = @"${date:format=HH\:mm\:ss} ${level} ${message} ${exception}"
};
config.AddTarget(debuggerTarget);
config.AddRuleForAllLevels(debuggerTarget);
var consoleTarget = new ConsoleTarget("console")
{
Layout = @"${date:format=HH\:mm\:ss} ${level} ${message} ${exception}"
};
config.AddTarget(consoleTarget);
config.AddRuleForAllLevels(consoleTarget);
config.AddRule(LogLevel.Fatal, LogLevel.Trace, consoleTarget);
LogManager.Configuration = config;
IndyDotNet.Utils.Logger.Init();
LogManager.GetCurrentClassLogger().Info("Logging started");
}
public MainWindow()
{
InitializeComponent();
vrTimer.Interval = 75;
vrTimer.Elapsed += OnVRTimer;
xinputTimer.Interval = 50;
xinputTimer.Elapsed += OnXInputTimer;
if (Application.Current == null)
{
return;
}
_log = LogManager.GetCurrentClassLogger();
LogManager.Configuration = LogManager.Configuration ?? new LoggingConfiguration();
#if DEBUG
// Debug Logger Setup
var t = new DebuggerTarget();
LogManager.Configuration.AddTarget("debugger", t);
LogManager.Configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, t));
LogManager.Configuration = LogManager.Configuration;
#endif
_intifaceTab.LogMessageHandler += OnLogMessage;
_modTab.MessageReceivedHandler += OnGVRMessageReceived;
_modTab.ProcessAttached += OnProcessAttached;
_modTab.ProcessDetached += OnProcessDetached;
_graphTab.MultiplierChanged += OnMultiplierChanged;
_graphTab.BaselineChanged += OnBaselineChanged;
_multiplier = _graphTab.Multiplier;
_baseline = _graphTab.Baseline;
//_graphTab.PassthruChanged += PassthruChanged;
_log.Info("Application started.");
_updateTask = _aboutTab.CheckForUpdate();
}
public static void AddDebugger(this LoggingConfiguration config)
{
var t = new DebuggerTarget();
config.AddTarget("debugger", t);
config.AddRuleForAllLevels(t);
}
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);
}
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 override void Load()
{
// log layout format
var layout = "${pad:padding=6:inner=${level:uppercase=true}} ${message} ${exception:separator=\r\n:format=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, 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, fileTarget));
// activate configuration and bind
LogManager.Configuration = config;
this.Kernel.Bind <Logger>().ToMethod(context => LogManager.GetLogger("BitSharp"));
}
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 = LogManager.Configuration ?? 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();
}
private static void InitializeLogging()
{
var config = new LoggingConfiguration();
var debuggerTarget = new DebuggerTarget();
config.AddTarget("debugger", debuggerTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, debuggerTarget));
var logFolder = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
Assembly.GetEntryAssembly().GetName().Name,
"Logs");
if (!Directory.Exists(logFolder))
{
Directory.CreateDirectory(logFolder);
}
var fileTarget = new FileTarget
{
FileName = Path.Combine(logFolder, "log.xml"),
ArchiveFileName = "log_{#####}.xml",
ArchiveNumbering = ArchiveNumberingMode.Rolling,
ArchiveAboveSize = 1024 * 1024,
Layout = new Log4JXmlEventLayout()
};
config.AddTarget("file", fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget));
LogManager.Configuration = config;
PresentationTraceSources.DataBindingSource.Listeners.Add(new NLogTraceListener());
}
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());
}
private static void ConfigureLogging()
{
var fileTarget = new FileTarget {
FileName = Path.Combine(_dataFolder, "log.xml"),
ArchiveFileName = "log_{#####}.xml",
ArchiveNumbering = ArchiveNumberingMode.Sequence,
ArchiveAboveSize = 1024 * 1024,
Layout = new Log4JXmlEventLayoutExtended()
};
var config = new LoggingConfiguration();
config.AddTarget("file", fileTarget);
var debuggerTarget = new DebuggerTarget();
config.AddTarget("debugger", debuggerTarget);
var rule1 = new LoggingRule("*", LogLevel.Debug, fileTarget);
config.LoggingRules.Add(rule1);
var rule2 = new LoggingRule("*", LogLevel.Debug, debuggerTarget);
config.LoggingRules.Add(rule2);
LogManager.Configuration = config;
Caliburn.Micro.LogManager.GetLog = type => new NLogLogger(type);
PresentationTraceSources.DataBindingSource.Listeners.Add(new NLogTraceListener());
}
internal NLogLogger(string name)
{
_path = LoggerHelpers.LoggerPath(name);
FileTarget file = new FileTarget();
file.MaxArchiveFiles = 10;
file.ArchiveAboveSize = 1 * 1024 * 1024;
file.CreateDirs = true;
file.FileName = _path;
file.Layout = "${date} (${threadid},${threadname}): ${message}";
LoggingConfiguration config = new LoggingConfiguration();
config.AddTarget("file", file);
config.LoggingRules.Add(new LoggingRule("*", file));
DebuggerTarget debug = new DebuggerTarget();
debug.Layout = file.Layout;
config.AddTarget("debug", debug);
config.LoggingRules.Add(new LoggingRule("*", debug));
NLog.LogManager.Configuration = config;
OnLogLevelChanged();
_impl = NLog.LogManager.GetLogger("main");
}
private 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 || TRUE
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.Debug, debuggerTarget);
config.LoggingRules.Add(debuggerRule);
var consoleRule = new LoggingRule("*", LogLevel.Debug, consoleTarget);
config.LoggingRules.Add(consoleRule);
LogManager.Configuration = config;
}
public MainWindow()
{
InitializeComponent();
if (Application.Current == null)
{
return;
}
_log = LogManager.GetCurrentClassLogger();
LogManager.Configuration = LogManager.Configuration ?? new LoggingConfiguration();
#if DEBUG
// Debug Logger Setup
var t = new DebuggerTarget();
LogManager.Configuration.AddTarget("debugger", t);
LogManager.Configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, t));
LogManager.Configuration = LogManager.Configuration;
#endif
_log.Info("Application started.");
server = new VAMLaunchServer();
_serverTask = new Task(() => server.UpdateThread());
_serverTask.Start();
// This is an event handler that will be executed on an outside thread, so remember to use dispatcher.
server.PositionUpdate += OnPositionUpdate;
}
public static void InitializeLogManager(string LogDirectory)
{
var logConfig = new LoggingConfiguration();
#if DEBUG
var minLevel = LogLevel.Trace;
#else
var minLevel = LogLevel.Trace;
#endif
#if DEBUG
var debug = new DebuggerTarget {
Layout = LogLayout
};
var debugRule = new LoggingRule("*", LogLevel.Debug, debug);
logConfig.LoggingRules.Add(debugRule);
logConfig.AddTarget("debug", debug);
#endif
var file = new FileTarget
{
Layout = LogLayout,
FileName = Path.Combine(LogDirectory, "${shortdate}.log"),
Encoding = Encoding.UTF8
};
logConfig.AddTarget("file", file);
//路由规则。loggerNamePattern且minLevel符合,输出到target
var fileRule = new LoggingRule("*", minLevel, file);
logConfig.LoggingRules.Add(fileRule);
LogManager.Configuration = logConfig;
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultTests"/> class.
/// </summary>
public ResultTests()
{
// configure the logger with a debugger target
LoggingConfiguration config = new LoggingConfiguration();
DebuggerTarget debug = new DebuggerTarget();
config.AddTarget("debug", debug);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, debug));
}
public static void AddDebuggerTarget(string minLevel = "Trace")
{
var config = LogManager.Configuration ?? new NLog.Config.LoggingConfiguration();
var debuggerTarget = new DebuggerTarget("Nlog");
config.AddTarget(debuggerTarget);
config.AddRule(LogLevel.FromString(minLevel), LogLevel.Fatal, debuggerTarget);
LogManager.Configuration = config;
}
public static void SetupLogging(LogLevel logLevel)
{
if (logLevel == LogManager.Configuration?.LoggingRules?.FirstOrDefault()?.Levels.FirstOrDefault())
{
return;
}
// 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);
var memoryTarget = new MemoryEventTarget();
memoryTarget.EventReceived += MemoryTargetOnEventReceived;
config.AddTarget("memory", memoryTarget);
// Step 3. Set target properties
debuggerTarget.Layout = @"${logger:shortName=True} - ${uppercase:${level}}: ${message}";
fileTarget.Layout = "${longdate}|${level:uppercase=true}|${logger}|${message} ${exception:format=tostring}";
fileTarget.FileName = "${specialfolder:folder=CommonApplicationData}/Artemis/logs/log.txt";
fileTarget.ArchiveFileName = "${specialfolder:folder=CommonApplicationData}/Artemis/logs/log-{#}.txt";
fileTarget.ArchiveEvery = FileArchivePeriod.Day;
fileTarget.ArchiveNumbering = ArchiveNumberingMode.Date;
fileTarget.ArchiveOldFileOnStartup = true;
fileTarget.MaxArchiveFiles = 7;
// Step 4. Define rules
var rule1 = new LoggingRule("*", logLevel, debuggerTarget);
config.LoggingRules.Add(rule1);
var rule2 = new LoggingRule("*", logLevel, fileTarget);
config.LoggingRules.Add(rule2);
var rule3 = new LoggingRule("*", logLevel, memoryTarget);
config.LoggingRules.Add(rule3);
// Step 5. Activate the configuration
LogManager.Configuration = config;
// Log as fatal so it always shows, add some spacing since this indicates the start of a new log
var logger = LogManager.GetCurrentClassLogger();
var logMsg = $" INFO: Set log level to {logLevel} ";
logger.Fatal(new string('-', logMsg.Length));
logger.Fatal(logMsg);
logger.Fatal(new string('-', logMsg.Length));
}
/// <summary>
/// Initializes static members of the <see cref="Helpers"/> class.
/// </summary>
static Helpers()
{
// configure the logger with a debugger target
LoggingConfiguration config = new LoggingConfiguration();
DebuggerTarget debug = new DebuggerTarget();
config.AddTarget("debug", debug);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, debug));
LogManager.Configuration = config;
}
private static void RegisterDebugger()
{
DebuggerTarget target = new DebuggerTarget();
target.Name = "debuggerLogger";
target.Layout = "[${level}] [${threadid}] ${logger}: ${message} ${onexception:inner=${newline}${newline}[v${assembly-version}] ${exception:format=ToString}${newline}}";
var loggingRule = new LoggingRule("*", LogLevel.Trace, target);
LogManager.Configuration.AddTarget("debugger", target);
LogManager.Configuration.LoggingRules.Add(loggingRule);
}
public void Initialize(LogLevel logLevel)
{
var config = new LoggingConfiguration();
const string logLayout = "${longdate} [${level:uppercase=true}] Thread: [${threadid}]${newline}" +
"${logger}:${callsite-linenumber} ${when:when=length('${threadname}') > 0: [${threadname}]}${newline}" +
"${message}${newline}" +
"${when:when=length('${exception}') > 0: ${exception}${newline}}";
if (logLevel == LogLevel.Debug)
{
_consoleTarget = new ColoredConsoleTarget();
_debuggerTarget = new DebuggerTarget();
_nLogViewerTarget = new NLogViewerTarget
{
Name = "sentinel",
Address = "udp://127.0.0.1:9999",
IncludeNLogData = true,
IncludeSourceInfo = true,
};
var sentinelRule = new LoggingRule("*", LogLevel.Trace, _nLogViewerTarget);
config.AddTarget("sentinel", _nLogViewerTarget);
config.LoggingRules.Add(sentinelRule);
config.AddTarget("console", _consoleTarget);
config.AddTarget("debugger", _debuggerTarget);
_consoleTarget.Layout = @"${date:format=HH\\:MM\\:ss} ${logger} [${threadid}]:${message} ${exception}";
_debuggerTarget.Layout = logLayout;
var consoleRule = new LoggingRule("*", LogLevel.Debug, _consoleTarget);
config.LoggingRules.Add(consoleRule);
var debuggerRule = new LoggingRule("*", LogLevel.Debug, _debuggerTarget);
config.LoggingRules.Add(debuggerRule);
}
else
{
_fileTarget = new FileTarget
{
ArchiveAboveSize = 2097152,
ArchiveEvery = FileArchivePeriod.Day,
ArchiveNumbering = ArchiveNumberingMode.Rolling,
MaxArchiveFiles = 5,
EnableArchiveFileCompression = true,
FileName = _storageLocationProvider.LogFile,
Layout = logLayout,
};
config.AddTarget("file", _fileTarget);
var fileRule = new LoggingRule("*", logLevel, _fileTarget);
config.LoggingRules.Add(fileRule);
}
LogManager.Configuration = config;
LogManager.ReconfigExistingLoggers();
}
public static void LogTo(TargetTypes targetType, string target, LogLevel minLevel, LogLevel maxLevel, bool final = false, string logFilter = "*")
{
Target loggingTarget;
switch (targetType)
{
case TargetTypes.File:
loggingTarget = new FileTarget(target)
{
FileName = "${basedir}/Logs/" + target + ".log"
, Layout = LogLayout
, KeepFileOpen = true
, ArchiveOldFileOnStartup = true
, ArchiveAboveSize = 45000000
};
break;
case TargetTypes.Console:
loggingTarget = new ColoredConsoleTarget(target)
{
Layout = LogLayout
};
break;
case TargetTypes.Memory:
loggingTarget = new MemoryTarget(target)
{
Layout = LogLayout
};
break;
case TargetTypes.Debugger:
loggingTarget = new DebuggerTarget(target)
{
Layout = LogLayout
};
break;
default: throw new Exception("No valid logging target found.");
}
// Step 3. Set target properties
_config.AddTarget(target, loggingTarget);
// Step 4. Define rules
var rule = new LoggingRule($"*{target}*", minLevel, maxLevel, loggingTarget)
{
Final = false
};
_config.LoggingRules.Add(rule);
// Step 5. Activate the configuration
LogManager.Configuration = _config;
}
public static LoggingConfiguration CreateForDebug(LogLevel logLevel)
{
var config = new LoggingConfiguration();
var target = new DebuggerTarget {
Name = "debug"
};
config.AddTarget(target);
config.LoggingRules.Add(new LoggingRule("*", logLevel, target));
return(config);
}
// Set MaxPingTime to zero (infinite ping/ping checks off) by default for tests
public TestLoggingServer(uint aMaxPingTime = 0, DeviceManager aDevManager = null)
: base(aMaxPingTime, aDevManager)
{
// Build ourselves an NLog manager just so we can see what's going on.
var dt = new DebuggerTarget();
LogManager.Configuration = new LoggingConfiguration();
LogManager.Configuration.AddTarget("debugger", dt);
LogManager.Configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, dt));
LogManager.Configuration = LogManager.Configuration;
}
private static void InitializeLogging()
{
var config = new LoggingConfiguration();
var debuggerTarget = new DebuggerTarget();
config.AddTarget("debugger", debuggerTarget);
var rule2 = new LoggingRule("*", LogLevel.Trace, debuggerTarget);
config.LoggingRules.Add(rule2);
LogManager.Configuration = config;
}
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");
}
static void Main()
{
#if DEBUG
var config = new LoggingConfiguration();
var debuggerTarget = new DebuggerTarget()
{
Layout = "${processtime} ${message:exceptionSeparator=\n\t:withException=true}"
};
config.AddTarget("debugger", debuggerTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, debuggerTarget));
LogManager.Configuration = config;
#endif
_log.Debug($"adrilight {VersionNumber}: Main() started.");
AppDomain.CurrentDomain.UnhandledException +=
(sender, args) => ApplicationOnThreadException(sender, args.ExceptionObject as Exception);
Settings.Load();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.ThreadException += (sender, args) => ApplicationOnThreadException(sender, args.Exception);
Application.ApplicationExit += (s, e) => _log.Debug("Application exit!");
SystemEvents.PowerModeChanged += (s, e) => _log.Debug("Changing Powermode to {0}", e.Mode);
SetupNotifyIcon();
//subscribe for changes in the settings
Properties.Settings.Default.PropertyChanged += (s, e) => SpotSet.Refresh();
//exeucte once to setup the leds
SpotSet.Refresh();
//subscribe for changes in the settings
Properties.Settings.Default.PropertyChanged += (s, e) => RefreshCapturingState();
//exeucte once to start the capturing initially
RefreshCapturingState();
//subscribe for changes in the settings
Properties.Settings.Default.PropertyChanged += (s, e) => RefreshTransferState();
//exeucte once to start the serial stream initially
RefreshTransferState();
if (!Settings.StartMinimized)
{
OpenSettingsWindow();
}
Application.Run();
}
static void InitializeLogging()
{
var config = new LoggingConfiguration();
var debuggerTarget = new DebuggerTarget("debugger")
{
Layout = @"${date:format=HH\:mm\:ss} ${level} ${message} ${exception}"
};
config.AddTarget(debuggerTarget);
config.AddRuleForAllLevels(debuggerTarget);
IndyDotNet.Utils.Logger.Init();
}
/// <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 = global::NLog.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");
}
}
