private static void InitLogging() { var s_Config = new LoggingConfiguration(); var s_ConsoleTarget = new ColoredConsoleTarget(); s_Config.AddTarget("console", s_ConsoleTarget); s_ConsoleTarget.Layout = @"[${date:format=HH\:mm\:ss.fff}] ${logger} >> ${message}"; var s_ConsoleRule = new LoggingRule("*", LogLevel.Trace, s_ConsoleTarget); s_Config.LoggingRules.Add(s_ConsoleRule); var s_FileTarget = new FileTarget(); s_Config.AddTarget("file", s_FileTarget); s_FileTarget.FileName = "${basedir}/GrooveCaster.log"; s_FileTarget.Layout = @"[${date:format=HH\:mm\:ss.fff}] ${logger} >> ${message}"; s_FileTarget.ArchiveFileName = "${basedir}/GrooveCaster.{#}.log"; s_FileTarget.ArchiveEvery = FileArchivePeriod.Day; s_FileTarget.ArchiveNumbering = ArchiveNumberingMode.Date; s_FileTarget.ArchiveDateFormat = "yyyMMdd"; var s_FileRule = new LoggingRule("*", LogLevel.Trace, s_FileTarget); s_Config.LoggingRules.Add(s_FileRule); LogManager.Configuration = s_Config; }
public static void LoadLoggerToLoggingConfig(LoggingConfiguration logConfig, IConfiguration Configuration,string sectionString) { var fileLoggerSection = Configuration.GetSection(sectionString).GetChildren(); foreach (var logging in fileLoggerSection) { var target = new FileTarget() { FileName = logging["fileName"], Name = logging["name"], Layout = logging["layoutFormat"] }; var minLevel = logging["minLevel"] != null ? LogLevel.FromString(logging["minLevel"]) : null; LoggingRule rule = null; if (minLevel != null) { rule = new LoggingRule(logging["namePattern"], minLevel, target); } else { rule = new LoggingRule(logging["namePattern"], target); } var useLevels = logging["logLevel"]; if(string.IsNullOrWhiteSpace(useLevels) == false) { var levels = useLevels.Split(','); foreach (var level in levels) { rule.EnableLoggingForLevel(LogLevel.FromString(level)); } } logConfig.AddTarget(target); logConfig.LoggingRules.Add(rule); } }
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(); } }
public static void AddFileLogger(string filePath) { //Find the existing console logger target var existingTarget = NLog.LogManager.Configuration.FindTargetByName <TargetWithLayout>("console"); if (existingTarget == null) { return; } var filename = Path.GetFileNameWithoutExtension(filePath) + DateTime.Now.ToString("_yyyyMMdd_hhmmss"); var basePath = Path.GetDirectoryName(filePath); var extension = Path.GetExtension(filePath); filePath = FileSystem.BuildPath(basePath, filename + extension); //Create a new target that uses the same settings var fileTarget = new NLog.Targets.FileTarget("file") { AutoFlush = true, Layout = existingTarget.Layout, CreateDirs = true, KeepFileOpen = true, FileName = filePath, }; AddTarget(fileTarget); }
public static LoggingConfiguration GetConfig() { var config = new NLog.Config.LoggingConfiguration(); //Targets where to log to: File and Console var logfile = new NLog.Targets.FileTarget("logfile") { FileName = $"log/{DateTime.Now.Day.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Year.ToString()}.txt" }; var consoleTarget = new ColoredConsoleTarget(); consoleTarget.Layout = "${date:format=HH\\:mm\\:ss} | ${callsite:className=true:includeNamespace=false:fileName=false:includeSourcePath=false:methodName=true} | [${level:uppercase=true}] : ${message}"; var highlightRule = new ConsoleRowHighlightingRule(); consoleTarget.WordHighlightingRules.Add(new ConsoleWordHighlightingRule("[INFO]", ConsoleOutputColor.DarkBlue, ConsoleOutputColor.NoChange)); consoleTarget.WordHighlightingRules.Add(new ConsoleWordHighlightingRule("[Send]", ConsoleOutputColor.DarkMagenta, ConsoleOutputColor.NoChange)); consoleTarget.WordHighlightingRules.Add(new ConsoleWordHighlightingRule("[Receive]", ConsoleOutputColor.DarkCyan, ConsoleOutputColor.NoChange)); consoleTarget.WordHighlightingRules.Add(new ConsoleWordHighlightingRule("[DEBUG]", ConsoleOutputColor.DarkGreen, ConsoleOutputColor.NoChange)); consoleTarget.WordHighlightingRules.Add(new ConsoleWordHighlightingRule("[ERROR]", ConsoleOutputColor.DarkRed, ConsoleOutputColor.NoChange)); //Rules for mapping loggers to targets config.AddRule(LogLevel.Debug, LogLevel.Fatal, consoleTarget); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); return(config); }
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; }
public Form1() { InitializeComponent(); MetaTypeSet.EventError += MetaTypeSet_EventError; // подписываемся на событие EventError. Если оно произойдет, то запустить метод (Analyze_EventError). Tree.EventError += Tree_EventError; #region Logs var config = new NLog.Config.LoggingConfiguration(); var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "log_file.txt" }; var logconsole = new NLog.Targets.ConsoleTarget("logconsole"); config.AddRule(LogLevel.Info, LogLevel.Fatal, logconsole); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); NLog.LogManager.Configuration = config; log = LogManager.GetCurrentClassLogger(); #endregion }
public static LoggingConfiguration GetNLogConfig() { _config = new LoggingConfiguration(); // Targets where to log to: File and Console var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "/home/jol/logs/evo-demo-${shortdate}.log", Layout = "${longdate} [${uppercase:${level}}] ${event-properties:item=EventId.Id}${newline}位置:${callsite:className=True:methodName=True:fileName=True:includeSourcePath=True:skipFrames=1}${newline}${message}${newline}${exception}${newline}", ArchiveAboveSize = 10485760, ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, ConcurrentWrites = true, MaxArchiveFiles = 100000, KeepFileOpen = false, }; var logconsole = new NLog.Targets.ConsoleTarget("logconsole") { Layout = "${longdate} [${uppercase:${level}}] ${event-properties:item=EventId.Id}${newline}位置:${callsite:className=True:methodName=True:fileName=True:includeSourcePath=True:skipFrames=1}${newline}${message}${newline}${exception}${newline}" }; // Rules for mapping loggers to targets _config.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, logconsole); _config.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Debug, logfile); return(_config); }
/// <summary> /// Initializes the NLog configuration /// </summary> /// <returns>A NLog logger</returns> private static Logger Initialize() { LogManager.Configuration = new LoggingConfiguration(); FileTarget target = new FileTarget(); target.Name = "file"; target.Layout = new SimpleLayout(@"${longdate} | ${level:uppercase=true} | ${message}"); target.FileName = new SimpleLayout(@"${specialfolder:ApplicationData}\TidyTabs\Debug.log"); target.ArchiveFileName = new SimpleLayout(@"${specialfolder:ApplicationData}\TidyTabs\Debug_Archive_{#}.log"); target.ArchiveEvery = FileArchivePeriod.Day; target.ArchiveNumbering = ArchiveNumberingMode.Rolling; target.MaxArchiveFiles = 3; target.KeepFileOpen = false; target.CreateDirs = true; target.Encoding = Encoding.UTF8; LoggingRule loggingRule = new LoggingRule("*", LogLevel.Info, target); LogManager.Configuration.AddTarget("logfile", target); LogManager.Configuration.LoggingRules.Add(loggingRule); LogManager.ReconfigExistingLoggers(); return LogManager.GetCurrentClassLogger(); }
void Application_Start(object sender, EventArgs e) { // Code that runs on application startup RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); //NLog configuration alternative to NLog.config >>>> var config = new NLog.Config.LoggingConfiguration(); FileTarget logfileTarget1 = new NLog.Targets.FileTarget("NLogExample.Model.ClassSon") { FileName = "NLogExample.Model.ClassSon.log" }; FileTarget logfileTarget2 = new NLog.Targets.FileTarget("NLogExample.Model.ClassDaughter") { FileName = "NLogExample.Model.ClassDaughter.log" }; //Format the output lines logfileTarget1.Layout = new NLog.Layouts.SimpleLayout("${longdate}|${uppercase:${level}}|" + "${ callsite:className=true:methodName=true} | ${message} "); logfileTarget2.Layout = new NLog.Layouts.SimpleLayout("${longdate}|${uppercase:${level}}|" + "${ callsite:className=true:methodName=true} | ${message} "); //!!LoggerNamePattern parameter is important to split the log strema into the files depending on the class instance!! config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfileTarget1, "NLogExample.Model.ClassSon"); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfileTarget2, "NLogExample.Model.ClassDaughter"); NLog.LogManager.Configuration = config; //<<<< NLog configuration }
public static void Configure() { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); // Step 3. Set target properties consoleTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}"; fileTarget.FileName = "${basedir}/SimplePerformanceMeter.txt"; fileTarget.Layout = "${message}"; // Step 4. Define rules var rule1 = new LoggingRule("*", LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", LogLevel.Debug, fileTarget); config.LoggingRules.Add(rule2); // Step 5. Activate the configuration LogManager.Configuration = config; }
public void FileAppenderCache_Allocate() { // Allocate on an Empty FileAppenderCache. FileAppenderCache emptyCache = FileAppenderCache.Empty; Assert.Throws<NullReferenceException>(() => emptyCache.AllocateAppender("file.txt")); // Construct a on non-empty FileAppenderCache. IFileAppenderFactory appenderFactory = SingleProcessFileAppender.TheFactory; ICreateFileParameters fileTarget = new FileTarget(); String tempFile = Path.Combine( Path.GetTempPath(), Path.Combine(Guid.NewGuid().ToString(), "file.txt") ); // Allocate an appender. FileAppenderCache cache = new FileAppenderCache(3, appenderFactory, fileTarget); BaseFileAppender appender = cache.AllocateAppender(tempFile); // // Note: Encoding is ASSUMED to be Unicode. There is no explicit reference to which encoding will be used // for the file. // // Write, flush the content into the file and release the file. // We need to release the file before invoking AssertFileContents() method. appender.Write(StringToBytes("NLog test string.")); appender.Flush(); appender.Close(); // Verify the appender has been allocated correctly. AssertFileContents(tempFile, "NLog test string.", Encoding.Unicode); }
protected virtual LoggingConfiguration SetupLogging(EndpointConfiguration endpointConfiguration) { var logDir = ".\\logfiles\\"; Directory.CreateDirectory(logDir); var logFile = Path.Combine(logDir, endpointConfiguration.EndpointName + ".txt"); if (File.Exists(logFile)) { File.Delete(logFile); } var logLevel = "INFO"; var nlogConfig = new LoggingConfiguration(); var fileTarget = new FileTarget { FileName = logFile, Layout = "${longdate}|${level:uppercase=true}|${threadid}|${logger}|${message}${onexception:inner=${newline}${exception}${newline}${stacktrace:format=DetailedFlat}}" }; nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", LogLevel.Warn, fileTarget) { Final = true }); nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.FromString(logLevel), fileTarget)); nlogConfig.AddTarget("debugger", fileTarget); NLogConfigurator.Configure(new object[] {fileTarget}, logLevel); return nlogConfig; }
/// <summary> /// Skapar och returnerar en logger, /// om det redan har skapats en logger tidigare så returneras den existerande. /// </summary> /// <returns>PersonsokLogger</returns> public static PersonsokLogger CreatePersonsokLogger() { LoggingConfiguration logConfig = new NLog.Config.LoggingConfiguration(); FileTarget logfile = new NLog.Targets.FileTarget("logfile") { FileName = "personsok.log" }; ConsoleTarget logconsole = new NLog.Targets.ConsoleTarget("logconsole"); logConfig.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, logconsole); logConfig.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Fatal, logfile); NLog.LogManager.Configuration = logConfig; IConfigurationRoot rootConfig = new ConfigurationBuilder() .SetBasePath(System.IO.Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .Build(); IServiceProvider serviceProvider = new ServiceCollection() .AddTransient <PersonsokLogger>() .AddLogging(loggingBuilder => { loggingBuilder.ClearProviders(); loggingBuilder.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace); loggingBuilder.AddNLog(rootConfig); }) .BuildServiceProvider(); return(serviceProvider.GetRequiredService <PersonsokLogger>()); }
public static void UseNLog(this IHost host) { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); var layout = @"${longdate}|${level:uppercase=true}|${threadid}|${logger}|${message}"; consoleTarget.Layout = layout; fileTarget.FileName = @"${tempdir}\${processname}\Log\${processname}.${processinfo:Id}.log"; fileTarget.ArchiveFileName = @"${tempdir}\${processname}\Log\${processname}.${processinfo:Id}.{###}.log"; fileTarget.ArchiveEvery = FileArchivePeriod.Day; fileTarget.ArchiveAboveSize = 1024000; fileTarget.ArchiveNumbering = ArchiveNumberingMode.Rolling; fileTarget.MaxArchiveFiles = 10; fileTarget.ConcurrentWrites = false; fileTarget.KeepFileOpen = false; fileTarget.Layout = layout; config.LoggingRules.Add(new LoggingRule("*", NLog.LogLevel.Debug, consoleTarget)); config.LoggingRules.Add(new LoggingRule("*", NLog.LogLevel.Info, fileTarget)); LogManager.Configuration = config; host.Container.RegisterType(typeof (ILogger<>), typeof (NLogger<>)); }
public static Logger BuildLogger() { var consoleTarget = new ColoredConsoleTarget { Layout = "${message} ${exception:format=tostring}" }; var fileName = Path.Combine(Path.GetTempPath(), "NancyOnKayak", "WebsiteLog_${shortdate}.log"); Console.WriteLine("Logging to:" + fileName); var fileTarget = new FileTarget { FileName = fileName, Layout = "${longdate} ${message} ${exception:format=tostring}", AutoFlush = true, }; var config = new LoggingConfiguration { LoggingRules = { new LoggingRule("*", LogLevel.Debug, consoleTarget), new LoggingRule("*", LogLevel.Debug, fileTarget), } }; config.AddTarget("file", fileTarget); config.AddTarget("console", consoleTarget); LogManager.Configuration = config; return LogManager.GetLogger(""); }
private static void Configure(INewRelicConfig config) { config = config ?? NewRelicConfig.Instance; LoggingConfiguration loggingConfiguration = new LoggingConfiguration(); ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget { Name = "Console" }; loggingConfiguration.AddTarget("Console", consoleTarget); loggingConfiguration.LoggingRules.Add(new LoggingRule("*", ToNLogLevel(config.LogLevel), consoleTarget)); // Store the LogLevel so it can be fetched by consumers LogLevel = config.LogLevel; if (config.LogFilePath.IsValidString() && config.LogFileName.IsValidString()) { long archiveAboveSize = config.LogLimitInKiloBytes == 0 ? long.MaxValue : config.LogLimitInKiloBytes * 1024; FileTarget fileTarget = new FileTarget { KeepFileOpen = true, ConcurrentWrites = false, FileName = Path.Combine(config.LogFilePath, config.LogFileName), MaxArchiveFiles = 1, ArchiveAboveSize = archiveAboveSize, Name = "File", }; loggingConfiguration.AddTarget("File", fileTarget); loggingConfiguration.LoggingRules.Add(new LoggingRule("*", ToNLogLevel(config.LogLevel), fileTarget)); } NLogManager.Configuration = loggingConfiguration; }
protected override LoggingConfiguration SetupLogging(EndpointConfiguration endpointConfiguration) { var logDir = ".\\logfiles\\"; Directory.CreateDirectory(logDir); var logFile = Path.Combine(logDir, endpointConfiguration.EndpointName + ".txt"); if (File.Exists(logFile)) { File.Delete(logFile); } var logLevel = "ERROR"; var nlogConfig = new LoggingConfiguration(); var fileTarget = new FileTarget { FileName = logFile, }; nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", LogLevel.Warn, fileTarget) { Final = true }); nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.FromString(logLevel), fileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("ServiceControl.ExternalIntegrations.*", LogLevel.Debug, fileTarget)); nlogConfig.AddTarget("debugger", fileTarget); NLogConfigurator.Configure(new object[] { fileTarget }, logLevel); return nlogConfig; }
/* Configure the logger programmatically. */ static NLoggerUtil() { var config = new LoggingConfiguration(); string path = "GhostFactor.log"; if (toDesktop) path = desktopPath + path; var target = new FileTarget { FileName = path }; // Add a file target where all the log shall go to. config.AddTarget("file", target); // Add a rule that any information higher than debug goes to the file. var rule = new LoggingRule("*", LogLevel.Debug, target); config.LoggingRules.Add(rule); // Also log fatal logs to another file. string fatalPath = "GhostFactorFatal.log"; if (toDesktop) fatalPath = desktopPath + fatalPath; var fatalTarget = new FileTarget() { FileName = fatalPath }; var fatalRule = new LoggingRule("*", LogLevel.Fatal, fatalTarget); config.LoggingRules.Add(fatalRule); LogManager.Configuration = config; }
private static Logger CreateLogger() { var config = new LoggingConfiguration(); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); fileTarget.FileName = "${basedir}\\AsteriskLog.txt"; fileTarget.Layout = "${date:format=yyyy-MM-dd HH\\:mm\\:ss}: ${message}"; fileTarget.ArchiveFileName = "${basedir}\\archives\\log.{#####}.txt"; fileTarget.ArchiveAboveSize = 10240000; fileTarget.ArchiveNumbering = ArchiveNumberingMode.Sequence; var rule = new LoggingRule("*", LogLevel.Trace, fileTarget); config.LoggingRules.Add(rule); var errorTarget = new FileTarget(); config.AddTarget("errorfile", errorTarget); errorTarget.FileName = "${basedir}\\Errors.txt"; errorTarget.Layout = "${date:format=yyyy-MM-dd HH\\:mm\\:ss}: ${message}"; errorTarget.ArchiveFileName = "${basedir}\\archives\\log.{#####}.txt"; errorTarget.ArchiveAboveSize = 10240000; errorTarget.ArchiveNumbering = ArchiveNumberingMode.Sequence; var errorsRule = new LoggingRule("*", LogLevel.Error, errorTarget); config.LoggingRules.Add(errorsRule); LogManager.Configuration = config; return LogManager.GetCurrentClassLogger(); }
private static void EnableFileLogging(RoslynInsertionToolOptions options) { var logConfig = LogManager.Configuration; // regular file logging var fileTarget = new NLog.Targets.FileTarget("file") { FileName = options.LogFileLocation, Layout = logConfig.Variables["VerboseLayout"] }; logConfig.AddTarget(fileTarget); logConfig.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, fileTarget); // exception logging var exceptionFilter = new NLog.Filters.ConditionBasedFilter() { Condition = "length('${exception}') > 0", Action = NLog.Filters.FilterResult.Ignore }; var exceptionFileTarget = new NLog.Targets.FileTarget("fileAsException") { FileName = options.LogFileLocation, Layout = logConfig.Variables["ExceptionVerboselayout"] }; var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, exceptionFileTarget); rule.Filters.Add(exceptionFilter); logConfig.LoggingRules.Add(rule); logConfig.Reload(); }
private static void Main(string[] args) { if (args.Length <= 0) { return; } var config = new LoggingConfiguration(); var logfile = new FileTarget(); var logdir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "HearthstoneTracker"); logdir = Path.Combine(logdir, "logs"); var logfilename = Path.Combine(logdir, "updater.${date:format=yyyy-MM-dd}.txt"); logfile.FileName = logfilename; logfile.CreateDirs = true; logfile.MaxArchiveFiles = 7; logfile.ArchiveEvery = FileArchivePeriod.Day; logfile.ConcurrentWrites = true; logfile.Layout = "${longdate}|${level:uppercase=true}|thread:${threadid}|${logger}|${message}${onexception:inner=${newline}${exception:format=tostring}}"; config.AddTarget("logfile", logfile); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, logfile)); LogManager.Configuration = config; Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new UpdateProgress(args)); }
/// <summary> /// Constructs an instance of DependencyRegistry /// </summary> public DependencyRegistry(ConfigSettings configSettings) { string logFileTemplate = configSettings.LogFileTemplate ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "default.log"); string dataDirectory = configSettings.DataDirectory ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "configdata"); LogLevel logLevel = GetMatchingLogLevelOrDefault(configSettings.LogLevel) ?? LogLevel.Info; For<IRepository<IJsonEntity<ConfigRoot>>>() .Singleton() .Use(new DurableMemoryRepository<ConfigRoot>(dataDirectory, new FileSystemFacade())); var config = new LoggingConfiguration(); var fileTarget = new FileTarget(); fileTarget.Name = "LogFile"; fileTarget.FileName = logFileTemplate; config.AddTarget(fileTarget.Name, fileTarget); var loggingRule = new LoggingRule("*", logLevel, fileTarget); config.LoggingRules.Add(loggingRule); LogManager.Configuration = config; For<ILogger>() .Singleton() .Use(l => new LoggerAdapter(LogManager.GetLogger(GetType().Namespace))); // Ask StructureMap to always do property injection for certain properties // TODO: remove this? SetAllProperties(policy => policy.OfType<ILogger>()); }
// ------------------------------------------ // Logs Management // ------------------------------------------ protected void SetupLogging() { var path = ConfigManager.GetInstance().Find("debug.log-file", null); if (null == path) { return; } LoggingConfiguration config = new LoggingConfiguration(); ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget(); consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; config.AddTarget("console", consoleTarget); FileTarget fileTarget = new FileTarget(); fileTarget.FileName = path; fileTarget.Layout = "${message}"; fileTarget.CreateDirs = true; config.AddTarget("file", fileTarget); LoggingRule rule1 = new LoggingRule("*", LogLevel.Info, consoleTarget); config.LoggingRules.Add(rule1); LoggingRule rule2 = new LoggingRule("*", LogLevel.Info, fileTarget); config.LoggingRules.Add(rule2); LoggingRule rule3 = new LoggingRule("*", LogLevel.Warn, consoleTarget); config.LoggingRules.Add(rule3); LoggingRule rule4 = new LoggingRule("*", LogLevel.Warn, fileTarget); config.LoggingRules.Add(rule4); // Ready LogManager.ReconfigExistingLoggers(); LogManager.Configuration = config; Host.Log(this, "STARTING LOGGING:" + fileTarget.FileName); }
public static void TargetFile(string fileName, bool verbose) { var target = new FileTarget { Layout = LayoutFormat, FileName = fileName }; NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, verbose ? LogLevel.Debug : LogLevel.Info); LogManager.ReconfigExistingLoggers(); }
private void ConfigureSharedFile(string mode, string fileName) { var modes = mode.Split('|'); FileTarget ft = new FileTarget(); ft.FileName = "${basedir}/" + fileName; ft.Layout = "${message}"; ft.KeepFileOpen = true; ft.OpenFileCacheTimeout = 10; ft.OpenFileCacheSize = 1; ft.LineEnding = LineEndingMode.LF; ft.ForceMutexConcurrentWrites = modes.Length == 2 && modes[1] == "mutex" ? true : false; var name = "ConfigureSharedFile_" + mode.Replace('|', '_') + "-wrapper"; switch (modes[0]) { case "async": SimpleConfigurator.ConfigureForTargetLogging(new AsyncTargetWrapper(ft, 100, AsyncTargetWrapperOverflowAction.Grow) { Name = name }, LogLevel.Debug); break; case "buffered": SimpleConfigurator.ConfigureForTargetLogging(new BufferingTargetWrapper(ft, 100) { Name = name }, LogLevel.Debug); break; case "buffered_timed_flush": SimpleConfigurator.ConfigureForTargetLogging(new BufferingTargetWrapper(ft, 100, 10) { Name = name }, LogLevel.Debug); break; default: SimpleConfigurator.ConfigureForTargetLogging(ft, LogLevel.Debug); break; } }
public static void EnableErrorLogging() { if (IsErrorLoggingEnabled) { return; } LoggingConfiguration config = LogManager.Configuration; FileTarget errorTarget = new FileTarget() { Name = "fileError", Layout = "-------------- ${level} (${longdate}) --------------${newline}" + "${newline}" + "Call Site: ${callsite}${newline}" + "Type: ${exception:format=Type}${newline}" + "Message: ${exception:format=Message}${newline}" + "Stack Trace: ${exception:format=StackTrace}${newline}" + "${newline}", FileName = BaseLogDirectory + @"\MobiBot\Error\error.log", ArchiveFileName = BaseLogDirectory + @"\MobiBot\Error\error.{###}.txt", ArchiveEvery = FileArchivePeriod.Day, ArchiveNumbering = ArchiveNumberingMode.Rolling, MaxArchiveFiles = 30, NetworkWrites = true, KeepFileOpen = true }; config.AddTarget(errorTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Error, errorTarget)); IsErrorLoggingEnabled = true; }
public void ConfigureNlog(Logger logger) { FileTarget target = new FileTarget(); target.FileName = "${basedir}\\logs\\ICtrl.Log_${date:format=ddMMyyyy}.txt"; target.KeepFileOpen = false; target.Encoding = "windows-1251"; target.Layout = "${date:format=HH\\:mm\\:ss.fff}|${level:padding=5:uppercase=true}|${message}"; AsyncTargetWrapper wrapper = new AsyncTargetWrapper(); wrapper.WrappedTarget = target; wrapper.QueueLimit = 5000; wrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Block; logOn = GetLogLevel(); switch (logOn) { case 1: NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(wrapper, LogLevel.Info); break; default: NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(wrapper, LogLevel.Off); break; } }
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); }
public void SimpleFileTest1() { string tempFile = Path.GetTempFileName(); try { FileTarget ft = new FileTarget(); ft.FileName = SimpleLayout.Escape(tempFile); ft.LineEnding = LineEndingMode.LF; ft.Layout = "${level} ${message}"; ft.OpenFileCacheTimeout = 0; SimpleConfigurator.ConfigureForTargetLogging(ft, LogLevel.Debug); logger.Debug("aaa"); logger.Info("bbb"); logger.Warn("ccc"); LogManager.Configuration = null; AssertFileContents(tempFile, "Debug aaa\nInfo bbb\nWarn ccc\n", Encoding.UTF8); } finally { if (File.Exists(tempFile)) File.Delete(tempFile); } }
private void BuildNlogConfig() { LoggingConfiguration config = new LoggingConfiguration(); // Create targets ConsoleTarget consoleTarget = new ConsoleTarget(); config.AddTarget("console", consoleTarget); FileTarget fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); //memoryTarget = new MemoryTarget(); //config.AddTarget("memory", memoryTarget); // define layout consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${level} ${logger} ${message}"; fileTarget.FileName = System.IO.Path.Combine(System.IO.Path.Combine(Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData), "monotorrent"), "monotorrent.log"); fileTarget.Layout = "${level} ${stacktrace} ${message}"; //memoryTarget.Layout = "${date:format=HH\\:MM\\:ss} ${level} ${logger} ${message}"; // define rules LoggingRule rule1 = new LoggingRule("*", LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule1); LoggingRule rule2 = new LoggingRule("*", LogLevel.Debug, fileTarget); config.LoggingRules.Add(rule2); //LoggingRule rule3 = new LoggingRule("*", LogLevel.Debug, fileTarget); //config.LoggingRules.Add(rule3); 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()); }
/// <summary> /// Initializes a new instance of the <see cref="MutexMultiProcessFileAppender" /> class. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="target">The file target.</param> public MutexMultiProcessFileAppender(string fileName, FileTarget target) : base(fileName) { try { this.mutex = new Mutex(false, GetMutexName(fileName)); this.file = target.CreateFileStream(fileName, true, true); } catch { if (this.mutex != null) { this.mutex.Close(); this.mutex = null; } if (this.file != null) { this.file.Close(); this.file = null; } throw; } }
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; }
private static Logger SetupNLog(NLogConfigurationApi config) { var logDirectory = string.IsNullOrEmpty(config.LogDirectory) ? "${basedir}/Logs" : config.LogDirectory; var fileTarget = new FileTarget { Name = "FileTarget", Layout = "${message}", ConcurrentWrites = false, FileName = new SimpleLayout(Path.Combine(logDirectory, "current.log")), ArchiveEvery = config.ArchivePeriod, ArchiveNumbering = ArchiveNumberingMode.Sequence, MaxArchiveFiles = config.MaxArchiveFiles, ArchiveFileName = new SimpleLayout(Path.Combine(logDirectory,"archive/{####}.log")) }; var asyncWrapper = new AsyncTargetWrapper(fileTarget) { Name = "AsyncWrapper" }; var loggingConfiguration = new LoggingConfiguration(); loggingConfiguration.AddTarget(LoggerName, asyncWrapper); loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LevelToNLogLevel(config.MinimumLogLevel), asyncWrapper)); LogManager.Configuration = loggingConfiguration; return LogManager.GetLogger(LoggerName); }
private static ILoggerFactory GetNLogLoggerFactory() { LoggingConfiguration loggerConfig = new NLog.Config.LoggingConfiguration(); FileTarget fileTarget = new NLog.Targets.FileTarget() { Name = "logfile", FileName = "log.txt", Layout = "${longdate}|${level:uppercase=true}|${logger}|${event-context:item=EventId}|${message}|${ndc}" }; loggerConfig.AddTarget(fileTarget); loggerConfig.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Info, fileTarget)); //NLogLoggerFactory test = new NLogLoggerFactory(new NLogLoggerProvider(new NLogProviderOptions())); NLogLoggerFactory logLoggerFactory = new NLogLoggerFactory(); NLogProviderOptions op = new NLogProviderOptions { CaptureMessageProperties = true, CaptureMessageTemplates = true, EventIdSeparator = "|", IgnoreEmptyEventId = false, IncludeScopes = true, //ParseMessageTemplates = true //ShutdownOnDispose = true }; NLogLoggerProvider p = new NLogLoggerProvider(op, loggerConfig.LogFactory); logLoggerFactory.AddProvider(p); return(logLoggerFactory); //loggerFactory.AddNLog(new NLog.LogFactory(loggerConfig)); }
private void ConfigureSharedFile(string mode) { FileTarget ft = new FileTarget(); ft.FileName = "${basedir}/file.txt"; ft.Layout = "${threadname} ${message}"; ft.KeepFileOpen = true; ft.OpenFileCacheTimeout = 10; ft.OpenFileCacheSize = 1; ft.LineEnding = LineEndingMode.LF; switch (mode) { case "async": SimpleConfigurator.ConfigureForTargetLogging(new AsyncTargetWrapper(ft, 100, AsyncTargetWrapperOverflowAction.Grow), LogLevel.Debug); break; case "buffered": SimpleConfigurator.ConfigureForTargetLogging(new BufferingTargetWrapper(ft, 100), LogLevel.Debug); break; case "buffered_timed_flush": SimpleConfigurator.ConfigureForTargetLogging(new BufferingTargetWrapper(ft, 100, 10), LogLevel.Debug); break; default: SimpleConfigurator.ConfigureForTargetLogging(ft, LogLevel.Debug); break; } }
public WPFLogger(MainWindow userForm) { form = userForm; //Cleanup old log if (File.Exists(Path.Combine(Directory.GetParent(App.GetExecutablePath()).FullName, "CaptureLog.txt"))) { File.Delete(Path.Combine(Directory.GetParent(App.GetExecutablePath()).FullName, "CaptureLog.txt")); } var LoggingConfig = new NLog.Config.LoggingConfiguration(); FileVersionInfo v = FileVersionInfo.GetVersionInfo(App.GetExecutablePath()); var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "${specialfolder:folder=ApplicationData:cached=true}/AmongUsCapture/logs/latest.log", ArchiveFileName = "${specialfolder:folder=ApplicationData:cached=true}/AmongUsCapture/logs/{#}.log", ArchiveNumbering = ArchiveNumberingMode.Date, Layout = "${time:universalTime=True} | ${message}", MaxArchiveFiles = 5, ArchiveOldFileOnStartup = true, ArchiveDateFormat = "yyyy-MM-dd HH_mm_ss", Header = $"Capture version: {v.FileMajorPart}.{v.FileMinorPart}.{v.FileBuildPart}.{v.FilePrivatePart}\n", Footer = $"\nCapture version: {v.FileMajorPart}.{v.FileMinorPart}.{v.FileBuildPart}.{v.FilePrivatePart}" }; LoggingConfig.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); NLog.LogManager.Configuration = LoggingConfig; logger = LogManager.GetLogger("WPFLogger"); }
public static void Configure() { var config = new NLog.Config.LoggingConfiguration(); var logfile = new NLog.Targets.FileTarget() { FileName = "file.txt", Name = "logfile" }; logfile.Layout = "Level : ${level} ${newline}When : ${longdate} ${newline}Message : ${message} ${newline}Machine Name : ${machinename} ${newline}Stack Trace : ${stacktrace} ${newline} "; // layout type = "log4net.Layout.PatternLayout" > //< IgnoresException value = "False" /> // ... config.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Error, logfile)); config.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Info, logfile)); logfile.ArchiveEvery = FileArchivePeriod.Day; logfile.ArchiveNumbering = ArchiveNumberingMode.Rolling; logfile.ConcurrentWrites = true; logfile.KeepFileOpen = false; logfile.ArchiveDateFormat = "yyyyMMdd"; LogManager.Configuration = config; }
public static void Configure() { var config = new LoggingConfiguration(); var fileTarget = new FileTarget(); fileTarget.FileName = Path.Combine(Util.get_log_folder(), "btnet_log.txt"); fileTarget.ArchiveNumbering = ArchiveNumberingMode.Date; fileTarget.ArchiveEvery = FileArchivePeriod.Day; config.AddTarget("File", fileTarget); var mailTarget = new MailTarget { UseSystemNetMailSettings = true, To = Util.get_setting("ErrorEmailTo", ""), From = Util.get_setting("ErrorEmailFrom", ""), Subject = "BTNET Error Notification", Layout = "${machinename}${newline} ${date} ${newline} ${newline} ${message} ${newline} ${exception} ${newline}" }; config.AddTarget("Mail", mailTarget); //Turn logging on/off based on the LogEnabled setting var logLevel = Util.get_setting("LogEnabled", "1") == "1" ? LogLevel.Trace: LogLevel.Off; config.LoggingRules.Add(new LoggingRule("*", logLevel, fileTarget)); var emailLogLevel = Util.get_setting("ErrorEmailEnabled", "1") == "1" ? LogLevel.Fatal : LogLevel.Off; config.LoggingRules.Add(new LoggingRule("*", emailLogLevel, mailTarget)); LogManager.Configuration = config; }
private void initLog() { var path = HostingEnvironment.MapPath("~/App_Data"); var config = new LoggingConfiguration(); var fileTarget = new FileTarget() { FileName = Path.Combine(path, "activity.log"), ArchiveFileName = Path.Combine(path, "activity.{#####}.log"), ArchiveAboveSize = 1024 * 1024, ArchiveNumbering = ArchiveNumberingMode.Sequence, ConcurrentWrites = false, Layout = "${longdate} | ${level} | ${logger} | ${message} ${exception:format=tostring}", AutoFlush = true, MaxArchiveFiles = 50 }; config.AddTarget("file", fileTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, fileTarget)); var traceTarget = new TraceTarget() { Layout = "${level} | ${logger} | ${message} ${exception:format=tostring}" }; config.AddTarget("trace", traceTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, traceTarget)); LogManager.Configuration = config; }
public void InitTargetFile(Session session) { //string dataTime = DateTime.Now.ToString("dd-MM-yyyy HH:mm:ss"); //":" in Path is not possible by windows // _filePath = _homeDir + "\\" +"LoggingData" + @"\${date:format=dd-MM-yyyy HH\:mm\:ss}.json"; /* * Set and hold the file Path by every runing */ var filePath = Path.Combine(_homeDir, "LoggingData", session.Name + ".json"); var logfile = new NLog.Targets.FileTarget("JsonLogger"); //set the layout of json format, MaxRecursionLimit can make sub object serialized, too!!! var jsonLayout = new JsonLayout { Attributes = { new JsonAttribute("session", session.Name), new JsonAttribute("time", "${longdate}"), new JsonAttribute("level", "${level:upperCase=true}"), new JsonAttribute("message", "${message}"), new JsonAttribute("eventProperties", new JsonLayout { IncludeAllProperties = true, MaxRecursionLimit = 10 }, false) } }; // set the attribute of the new target logfile.Name = "JsonLogger"; logfile.FileName = filePath; logfile.Layout = jsonLayout; // add the new target to current configuration NLog.LogManager.Configuration.AddTarget(logfile); // create new rule var rule = new LoggingRule("JsonLogger", LogLevel.Trace, logfile); NLog.LogManager.Configuration.LoggingRules.Add(rule); /* * reload the new configuration. It's very important here. * Do not use NLog.LogManager.Configuration = config; * This will destory current configuration. * So just add and reload. */ LogManager.Configuration.Reload(); // get the specified Logger _logger = NLog.LogManager.GetLogger("JsonLogger"); }
/** * Configures the Console/File logging. * * TODO: make it configurable (log levels, file name). */ public static void ConfigureLogging() { var config = new NLog.Config.LoggingConfiguration(); var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "app.log" }; var logconsole = new NLog.Targets.ConsoleTarget("logconsole"); config.AddRule(LogLevel.Info, LogLevel.Fatal, logconsole); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); NLog.LogManager.Configuration = config; }
public DependenciesConfiguration() { LoggingConfiguration config = new NLog.Config.LoggingConfiguration(); FileTarget logfile = new NLog.Targets.FileTarget("logfile") { FileName = "debugOutput.txt" }; ConsoleTarget logconsole = new NLog.Targets.ConsoleTarget("logconsole"); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); NLog.LogManager.Configuration = config; }
private Logger() { LayoutRenderer.Register <LayoutRenderers.ElapsedTimeLayoutRenderer>("elapsed-time"); LayoutRenderer.Register <LayoutRenderers.RealTimeLayoutRenderer>("real-time"); var config = new NLog.Config.LoggingConfiguration(); var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "pluginlog.log", ArchiveEvery = NLog.Targets.FileArchivePeriod.Day, MaxArchiveFiles = 10, ArchiveFileName = "logs/log.{###}.log", ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.Rolling }; config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); NLog.LogManager.Configuration = config; log = LogManager.GetCurrentClassLogger(); LogMessage(TracingLevel.DEBUG, "Logger Initialized"); }
/* función estática InitLogger() => void * Inicializa el servicio de logging de la aplicación */ public static void InitLogger() { LoggingConfiguration config = new NLog.Config.LoggingConfiguration(); // Establece las salidas de logging a consola y archivo Target logconsole = new NLog.Targets.ConsoleTarget("logconsole"); Target logfile = new NLog.Targets.FileTarget("logfile") { FileName = "nlog.log" }; // Añade las reglas de configuración con los umbrales de los niveles de seguridad config.AddRule(LogLevel.Info, LogLevel.Fatal, logconsole); config.AddRule(LogLevel.Info, LogLevel.Fatal, logfile); // Aplica la configuración NLog.LogManager.Configuration = config; }
public void SetupLoggingConfig() { var LoggingConfig = new NLog.Config.LoggingConfiguration(); FileVersionInfo v = FileVersionInfo.GetVersionInfo(App.GetExecutablePath()); var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "${specialfolder:folder=ApplicationData:cached=true}/AmongUsCapture/logs/latest.log", ArchiveFileName = "${specialfolder:folder=ApplicationData:cached=true}/AmongUsCapture/logs/{#}.log", ArchiveNumbering = ArchiveNumberingMode.Date, Layout = "${time:universalTime=True}|${level:uppercase=true}|${logger}|${message}", MaxArchiveFiles = 100, ArchiveOldFileOnStartup = true, ArchiveDateFormat = "yyyy-MM-dd HH_mm_ss", Header = $"Capture version: {v.FileMajorPart}.{v.FileMinorPart}.{v.FileBuildPart}.{v.FilePrivatePart}\n", Footer = $"\nCapture version: {v.FileMajorPart}.{v.FileMinorPart}.{v.FileBuildPart}.{v.FilePrivatePart}" }; LoggingConfig.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); NLog.LogManager.Configuration = LoggingConfig; }
private void SetUpNLog() { var config = new NLog.Config.LoggingConfiguration(); // Targets where to log to: File and Console var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "backupclientlogfile_helperservice.txt" }; var logconsole = new NLog.Targets.ConsoleTarget("logconsole"); // Rules for mapping loggers to targets config.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, logconsole); config.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, logfile); // Apply config LogManager.Configuration = config; _logger = LogManager.GetCurrentClassLogger(); }
public static void Initialize(string logFile, MsixHeroLogLevel minLogLevel = MsixHeroLogLevel.Debug, MsixHeroLogLevel maxLogLevel = MsixHeroLogLevel.Fatal) { if (string.IsNullOrEmpty(logFile)) { throw new ArgumentNullException(nameof(logFile)); } var config = new NLog.Config.LoggingConfiguration(); var logfile = new NLog.Targets.FileTarget { FileName = logFile, Header = GetHeader(), Layout = "${longdate}\t${level:uppercase=true}\t${logger}\t${message}\t${exception:format=tostring}" }; config.AddRule(Convert(minLogLevel), Convert(maxLogLevel), logfile); config.AddRule(Convert(minLogLevel), Convert(maxLogLevel), new ConsoleTarget()); NLog.LogManager.Configuration = config; }
// DiscordSocketClient and CommandService are injected automatically from the IServiceProvider public LoggingService(DiscordSocketClient discord, CommandService commands) { _logDirectory = Path.Combine(AppContext.BaseDirectory, "logs"); _discord = discord; _commands = commands; _discord.Log += OnLogAsync; _commands.Log += OnLogAsync; var logConfig = new NLog.Config.LoggingConfiguration(); var logFile = new NLog.Targets.FileTarget("logFile") { FileName = _logFile, ArchiveEvery = FileArchivePeriod.Day }; var logConsole = new NLog.Targets.ConsoleTarget("logConsole"); logConfig.AddRule(LogLevel.Info, LogLevel.Fatal, logFile); logConfig.AddRule(LogLevel.Info, LogLevel.Fatal, logConsole); NLog.LogManager.Configuration = logConfig; }
protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); // Set our view from the "main" layout resource SetContentView(Resource.Layout.Main); Button button = FindViewById <Button>(Resource.Id.btnTest); var externalFolder = GetExternalFilesDir(null); var config = new NLog.Config.LoggingConfiguration(); var logfile = new NLog.Targets.FileTarget() { FileName = externalFolder + "/afile.log", Name = "logfile" }; config.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Info, logfile)); var consoleView = FindViewById <TextView>(Resource.Id.resultsView); var consoleTarget = new MyFirstTarget(consoleView, this); consoleTarget.Layout = NLog.Layouts.Layout.FromString("${longdate} | ${message}"); config.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Info, consoleTarget)); LogManager.Configuration = config; logger.Trace("Logger Started"); button.Click += delegate { TestTransaction(); }; CheckThisIsDefault(); }
static void Main(string[] args) { /* Set up logging configuration */ var config = new NLog.Config.LoggingConfiguration(); var logfile = new NLog.Targets.FileTarget("logfile") { Layout = @"[${longdate}] [${level}] [${callsite}:${callsite-linenumber}] ${message} ${exception}", FileName = Settings.outdir + "\\SWDecoder_" + Settings.epoch + ".log" }; var logconsole = new ColoredConsoleTarget("logconsole") { Layout = @"[${longdate}] [${level}] ${message} ${exception}" }; var lognullstream = new NLog.Targets.NullTarget(); config.AddRule(LogLevel.Info, LogLevel.Fatal, logfile, "SWDecoder*"); // Only log from the SWDecoder logger and ignore libraries config.AddRule(LogLevel.Info, LogLevel.Fatal, logconsole, "SWDecoder*"); NLog.LogManager.Configuration = config; Console.WriteLine(" _____ _ ______ _ "); Console.WriteLine("/ ___| | | | _ \\ | | "); Console.WriteLine("\\ `--. ___ | |_ __| | | |___ ___ ___ __| | ___ _ __ "); Console.WriteLine(" `--. \\/ _ \\| | '__| | | / _ \\/ __/ _ \\ / _` |/ _ \\ '__|"); Console.WriteLine("/\\__/ / (_) | | | | |/ / __/ (_| (_) | (_| | __/ | "); Console.WriteLine("\\____/ \\___/|_|_| |___/ \\___|\\___\\___/ \\__,_|\\___|_| "); Console.WriteLine(" "); Console.WriteLine("======== A tool to convert compressed base64 compressed strings to plaintext ============"); CommandLine.Parser.Default.ParseArguments <Options>(args) .WithParsed <Options>(o => { Settings.infile = Path.GetFullPath(o.InputPath.TrimEnd('\\')); Settings.outdir = Path.GetFullPath(o.OutputPath.TrimEnd('\\')); }) .WithNotParsed(HandleParseError); _log.Info("Reading the input file"); FileRead.readFile(); }
public MainWindow() { InitializeComponent(); //Sets default properties rows from project settings settingshandler = new SettingsHandler(sp_settings); #region logger init var config = new NLog.Config.LoggingConfiguration(); var logfile = new NLog.Targets.FileTarget() { FileName = "log.txt", Name = "logfile" }; var logconsole = new NLog.Targets.ConsoleTarget() { Name = "logconsole" }; config.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Info, logconsole)); config.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Debug, logfile)); NLog.LogManager.Configuration = config; //Logger logger = NLog.LogManager.GetCurrentClassLogger(); #endregion logger.Info("start"); //checking net status indikacenetu(); Connection.CheckingConnection(); GetterInit(settingshandler.getUrlTB()); //int Desc; //if (!InternetGetConnectedState(out Desc, 0)) // lb_status.Content = "No connection"; }
public static void ConfigureNLog() { try { var config = new NLog.Config.LoggingConfiguration(); var minLogLevel = LogLevel.FromString(Environment.GetEnvironmentVariable("LOGGING_MIN_LEVEL")); var maxLogLevel = LogLevel.FromString(Environment.GetEnvironmentVariable("LOGGING_MAX_LEVEL")); //console logging var logconsole = new NLog.Targets.ConsoleTarget("logconsole"); config.AddRule(minLogLevel, maxLogLevel, logconsole); if (Globals.EnableFileLogging) { // file loggin var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "logfile.log" }; config.AddRule(minLogLevel, maxLogLevel, logfile); } if (Globals.EnableDBLogging) { //db loggin var logdb = new NLog.Targets.DatabaseTarget("logdb"); logdb.CommandText = @" insert into [Log] (MachineName, Logged, Level, Message,Logger, Properties, Callsite, Exception) values (@MachineName, @Logged, @Level, @Message, @Logger, @Properties, @Callsite, @Exception);"; logdb.CommandType = System.Data.CommandType.Text; logdb.ConnectionString = Globals.SkillbaseConnectionString; logdb.Parameters.Add(new DatabaseParameterInfo() { Name = "@MachineName", Layout = "${machinename}" }); logdb.Parameters.Add(new DatabaseParameterInfo() { Name = "@Logged", Layout = "${date}" }); logdb.Parameters.Add(new DatabaseParameterInfo() { Name = "@Level", Layout = "${level}" }); logdb.Parameters.Add(new DatabaseParameterInfo() { Name = "@Message", Layout = "${message}" }); logdb.Parameters.Add(new DatabaseParameterInfo() { Name = "@Logger", Layout = "${logger}" }); logdb.Parameters.Add(new DatabaseParameterInfo() { Name = "@Properties", Layout = "${all-event-properties:separator=|}" }); logdb.Parameters.Add(new DatabaseParameterInfo() { Name = "@Callsite", Layout = "${callsite}" }); logdb.Parameters.Add(new DatabaseParameterInfo() { Name = "@Exception", Layout = "${exception:tostring}" }); config.AddRule(minLogLevel, maxLogLevel, logdb); } // Apply config NLog.LogManager.Configuration = config; } catch (Exception) { } }
// TODO remove forced mode checkbox? public BmpMain() { InitializeComponent(); SetupCommands(); this.UpdatePerformance(); BmpUpdate update = new BmpUpdate(); if (!Program.programOptions.DisableUpdate) { updateResult = update.ShowDialog(); if (updateResult == DialogResult.Yes) { updateTitle = update.version.updateTitle; updateText = update.version.updateText; updateResult = DialogResult.Yes; } } this.Text = update.version.ToString(); // Clear local orchestra InfoTabs.TabPages.Remove(localOrchestraTab); FFXIV.findProcessRequest += delegate(Object o, EventArgs empty) { this.Invoke(t => t.FindProcess()); }; FFXIV.findProcessError += delegate(Object o, BmpHook.ProcessError error) { this.Invoke(t => t.ErrorProcess(error)); }; FFXIV.hotkeys.OnFileLoad += delegate(Object o, EventArgs empty) { this.Invoke(t => t.Hotkeys_OnFileLoad(FFXIV.hotkeys)); }; FFXIV.hook.OnKeyPressed += Hook_OnKeyPressed; FFXIV.memory.OnProcessReady += delegate(object o, Process proc) { this.Log(string.Format("[{0}] Process scanned and ready.", proc.Id)); }; FFXIV.memory.OnProcessLost += delegate(object o, EventArgs arg) { this.Log("Attached process exited."); }; FFXIV.memory.OnChatReceived += delegate(object o, ChatLogItem item) { this.Invoke(t => t.Memory_OnChatReceived(item)); }; FFXIV.memory.OnPerformanceChanged += delegate(object o, List <uint> ids) { this.Invoke(t => t.LocalOrchestraUpdate((o as FFXIVMemory).GetActorItems(ids))); }; FFXIV.memory.OnPerformanceReadyChanged += delegate(object o, bool performance) { this.Invoke(t => t.Memory_OnPerformanceReadyChanged(performance)); }; FFXIV.memory.OnCurrentPlayerJobChange += delegate(object o, CurrentPlayerResult res) { this.Invoke(t => t.Memory_OnCurrentPlayerJobChange(res)); }; FFXIV.memory.OnCurrentPlayerLogin += delegate(object o, CurrentPlayerResult res) { string format = string.Format("Character [{0}] logged in.", res.CurrentPlayer.Name); this.Log(format); this.Invoke(t => t.UpdatePerformance()); }; FFXIV.memory.OnCurrentPlayerLogout += delegate(object o, CurrentPlayerResult res) { string format = string.Format("Character [{0}] logged out.", res.CurrentPlayer.Name); this.Log(format); }; FFXIV.memory.OnPartyChanged += delegate(object o, PartyResult res) { this.Invoke(t => t.LocalOrchestraUpdate()); }; Player.OnStatusChange += delegate(object o, PlayerStatus status) { this.Invoke(t => t.UpdatePerformance()); }; Player.OnSongSkip += OnSongSkip; Player.OnMidiLyric += OnMidiLyric; Player.OnMidiStatusChange += OnPlayStatusChange; Player.OnMidiStatusEnded += OnPlayStatusEnded; Player.OnMidiNote += OnMidiVoice; Player.OffMidiNote += OffMidiVoice; Player.Player.OpenInputDevice(Settings.GetMidiInput().name); Settings.OnMidiInputChange += delegate(object o, MidiInput input) { Player.Player.CloseInputDevice(); if (input.id != -1) { Player.Player.OpenInputDevice(input.name); Log(string.Format("Switched to {0} ({1})", input.name, input.id)); } }; Settings.OnKeyboardTest += delegate(object o, EventArgs arg) { foreach (FFXIVKeybindDat.Keybind keybind in FFXIV.hotkeys.GetPerformanceKeybinds()) { FFXIV.hook.SendSyncKeybind(keybind); Thread.Sleep(100); } }; Settings.OnForcedOpen += delegate(object o, bool open) { this.Invoke(t => t.UpdatePerformance()); }; chordNotes = new NoteChordSimulation <BmpPlayer.NoteEvent>(); chordNotes.NoteEvent += OnMidiVoice; Explorer.OnBrowserVisibleChange += delegate(object o, bool visible) { MainTable.RowStyles[MainTable.GetRow(ChatPlaylistTable)].Height = visible ? 0 : 100; MainTable.RowStyles[MainTable.GetRow(ChatPlaylistTable)].SizeType = visible ? SizeType.Absolute : SizeType.Percent; //ChatPlaylistTable.Invoke(t => t.Visible = !visible); MainTable.RowStyles[MainTable.GetRow(Explorer)].Height = visible ? 100 : 30; MainTable.RowStyles[MainTable.GetRow(Explorer)].SizeType = visible ? SizeType.Percent : SizeType.Absolute; }; Explorer.OnBrowserSelect += Browser_OnMidiSelect; Playlist.OnMidiSelect += Playlist_OnMidiSelect; Playlist.OnPlaylistRequestAdd += Playlist_OnPlaylistRequestAdd; if (Properties.Settings.Default.SaveLog) { FileTarget target = new NLog.Targets.FileTarget("chatlog") { FileName = "logs/ff14log.txt", Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} ${message}", ArchiveDateFormat = "${shortdate}", ArchiveEvery = FileArchivePeriod.Day, ArchiveFileName = "logs/ff14log-${shortdate}.txt", Encoding = Encoding.UTF8, }; var config = new NLog.Config.LoggingConfiguration(); config.AddRule(LogLevel.Info, LogLevel.Info, target); NLog.LogManager.Configuration = config; } string upath = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoaming).FilePath; //Console.WriteLine(string.Format(".config: [{0}]", upath)); Settings.RefreshMidiInput(); Log("Bard Music Player initialized."); }
public async Task UpdateNLog(LogLevel MinLevel, string Filename, long MaxSize, int MaxAgeDays, int MaxGUILogItems) { try { this.MaxGUILogItems = MaxGUILogItems; bool needsupdating = this.NLogFileWriter == null || this.NLogAsyncWrapper == null || MinLevel != this.MinLevel || Filename != this._Filename || MaxSize != this._MaxSize || MaxAgeDays != this._MaxAgeDays; if (!needsupdating) { return; } //if we change the logging level only, I dont want to re-initialize everything else... bool onlylevel = this.NLogFileWriter != null && this.NLogAsyncWrapper != null && MinLevel != this.MinLevel && Filename == this._Filename && MaxSize == this._MaxSize && MaxAgeDays == this._MaxAgeDays; if (onlylevel) { this.MinLevel = MinLevel; foreach (var rule in LogManager.Configuration.LoggingRules) { rule.EnableLoggingForLevel(this.MinLevel); } //Call to update existing Loggers created with GetLogger() or //GetCurrentClassLogger() LogManager.ReconfigExistingLoggers(); this._Filename = this.GetCurrentLogFileName(); return; } if (this.NLogAsyncWrapper == null) { this.NLogAsyncWrapper = new AsyncTargetWrapper(); } this.MinLevel = MinLevel; this._MaxAgeDays = MaxAgeDays; this._MaxSize = MaxSize; // Targets where to log to: File and Console var FileTarget = new NLog.Targets.FileTarget("logfile"); // { FileName = AppSettings.Settings.LogFileName }; string dir = Path.GetDirectoryName(Filename); string justfile = Path.GetFileNameWithoutExtension(Filename); //${basedir}/${shortdate}.log FileTarget.FileName = dir + "\\" + justfile + ".[${shortdate}].log"; FileTarget.ArchiveAboveSize = MaxSize; FileTarget.ArchiveEvery = NLog.Targets.FileArchivePeriod.Day; FileTarget.MaxArchiveDays = MaxAgeDays; FileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence; FileTarget.ArchiveOldFileOnStartup = false; FileTarget.ArchiveDateFormat = "yyyy-MM-dd"; FileTarget.ArchiveFileName = dir + "\\" + justfile + ".[{#}].log.zip"; FileTarget.KeepFileOpen = false; FileTarget.CreateDirs = true; FileTarget.Header = "Date|Level|Source|Func|AIServer|Camera|Image|Detail|Idx|Depth|Color|ThreadID"; FileTarget.EnableArchiveFileCompression = true; FileTarget.Layout = "${message}"; //nothing fancy we are doing it ourselves this.NLogAsyncWrapper.WrappedTarget = FileTarget; this.NLogAsyncWrapper.QueueLimit = 100; this.NLogAsyncWrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Discard; this.NLogAsyncWrapper.Name = "NLogAsyncWrapper"; // Rules for mapping loggers to targets NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(this.NLogAsyncWrapper, this.MinLevel); NLog.LogManager.AutoShutdown = true; this.NLogFileWriter = NLog.LogManager.GetCurrentClassLogger(); //this.NLogAsyncWrapper.EventQueueGrow //this.NLogAsyncWrapper.LogEventDropped if (this.Values.Count == 0) { this.GetCurrentLogFileName(); } //load the current log file into memory //await this.LoadLogFileAsync(this._Filename, true, false); } catch (Exception ex) { Console.WriteLine("Error: " + Global.ExMsg(ex)); } }
public NLogger(LogOptions options = null) { options = options ?? new LogOptions { EnableConsoleLog = true }; var config = new NLog.Config.LoggingConfiguration(); if (options.EnableFileLog) { var fileConf = new NLog.Targets.FileTarget("jimuLogFile") { FileName = ".\\log\\${level:lowercase=true}\\${shortdate}.log", ArchiveAboveSize = 10000000, Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss.fff} ${level:uppercase=true} ${message}" }; if ((options.FileLogLevel & LogLevel.Error) == LogLevel.Error) { config.AddRuleForOneLevel(NLog.LogLevel.Error, fileConf); } if ((options.FileLogLevel & LogLevel.Warn) == LogLevel.Warn) { //config.AddRuleForOneLevel(NLog.LogLevel.Warn, fileConf); config.AddRule(NLog.LogLevel.Warn, NLog.LogLevel.Error, fileConf); } if ((options.FileLogLevel & LogLevel.Info) == LogLevel.Info) { config.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Error, fileConf); //config.AddRuleForOneLevel(NLog.LogLevel.Info, fileConf); } if ((options.FileLogLevel & LogLevel.Debug) == LogLevel.Debug) { config.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Error, fileConf); //config.AddRuleForOneLevel(NLog.LogLevel.Debug, fileConf); } } if (options.EnableConsoleLog) { var consoleLog = new NLog.Targets.ConsoleTarget("jimuLogconsole") { Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss.fff} ${level:uppercase=true} ${message}" }; if ((options.ConsoleLogLevel & LogLevel.Error) == LogLevel.Error) { config.AddRuleForOneLevel(NLog.LogLevel.Error, consoleLog); } if ((options.ConsoleLogLevel & LogLevel.Warn) == LogLevel.Warn) { config.AddRule(NLog.LogLevel.Warn, NLog.LogLevel.Error, consoleLog); //config.AddRuleForOneLevel(NLog.LogLevel.Warn, consoleLog); } if ((options.ConsoleLogLevel & LogLevel.Info) == LogLevel.Info) { config.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Error, consoleLog); //config.AddRuleForOneLevel(NLog.LogLevel.Info, consoleLog); } if ((options.ConsoleLogLevel & LogLevel.Debug) == LogLevel.Debug) { config.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Error, consoleLog); //config.AddRuleForOneLevel(NLog.LogLevel.Debug, consoleLog); } } NLog.LogManager.Configuration = config; _logger = NLog.LogManager.GetLogger("jimuLogger"); }
public Logger(bool isClassLogger = true) { var appName = Environment.GetEnvironmentVariable("AppName"); #if !UNITY_5_3_OR_NEWER var config = new NLog.Config.LoggingConfiguration(); string logFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "../../logs"); if (!Directory.Exists(logFolder)) { Directory.CreateDirectory(logFolder); } string logFilePath = Path.Combine(logFolder, appName + ".log"); Console.WriteLine("CreateLogFile: " + logFilePath); var logfile = new NLog.Targets.FileTarget("logfile") { FileName = logFilePath, Layout = new NLog.Layouts.SimpleLayout("${longdate} [${level:uppercase=true}] [${threadid}] ${callsite} - ${message}"), ArchiveFileName = "${basedir}/logs/archived/" + appName + ".{#####}.log", ArchiveAboveSize = 100000000 /* 100 MB */, ArchiveNumbering = ArchiveNumberingMode.Sequence, ConcurrentWrites = true, KeepFileOpen = false, MaxArchiveFiles = 10, }; if (!isClassLogger) { logfile.Layout = new NLog.Layouts.SimpleLayout("${longdate} [${level:uppercase=true}] [${threadid}] ${logger} - ${message}"); } var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole"); AsyncTargetWrapper wrapper = new AsyncTargetWrapper(); wrapper.WrappedTarget = logfile; wrapper.QueueLimit = 5000; wrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Grow; AsyncTargetWrapper wrapper2 = new AsyncTargetWrapper(); wrapper2.WrappedTarget = logconsole; wrapper2.QueueLimit = 5000; wrapper2.OverflowAction = AsyncTargetWrapperOverflowAction.Grow; config.AddTarget("asyncFile", wrapper); config.AddTarget("asyncConsole", wrapper2); config.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, wrapper2); config.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Fatal, wrapper); NLog.LogManager.Configuration = config; if (isClassLogger) { NLogger = NLog.LogManager.GetCurrentClassLogger(); } else { NLogger = NLog.LogManager.GetLogger(appName); } #else string logFolder = Path.Combine(Unity.Common.IOUtil.persistentDataPath, "logs"); if (!Directory.Exists(logFolder)) { Directory.CreateDirectory(logFolder); } string logFilePath = Path.Combine(logFolder, appName + ".log"); Console.WriteLine("CreateLogFile: " + logFilePath); var logfile = new NLog.Targets.FileTarget("logfile") { FileName = logFilePath, Layout = new NLog.Layouts.SimpleLayout("${longdate} [${level:uppercase=true}] [${threadid}] ${callsite} - ${message}"), ArchiveFileName = "${basedir}/logs/archived/" + appName + ".{#####}.log", ArchiveAboveSize = 100000000 /* 100 MB */, ArchiveNumbering = ArchiveNumberingMode.Sequence, ConcurrentWrites = true, KeepFileOpen = false, MaxArchiveFiles = 10, }; if (!isClassLogger) { logfile.Layout = new NLog.Layouts.SimpleLayout("${longdate} [${level:uppercase=true}] [${threadid}] ${logger} - ${message}"); } AsyncTargetWrapper wrapper = new AsyncTargetWrapper(); wrapper.WrappedTarget = logfile; wrapper.QueueLimit = 5000; wrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Grow; AsyncTargetWrapper wrapperUnity = new AsyncTargetWrapper(); if (isClassLogger) { wrapperUnity.WrappedTarget = Unity.Common.LogUtil.CreateUnityConsoleTarget("unityconsole", "${longdate} [${level:uppercase=true}] [${threadid}] ${callsite} - ${message}"); } else { wrapperUnity.WrappedTarget = Unity.Common.LogUtil.CreateUnityConsoleTarget("unityconsole", "${longdate} [${level:uppercase=true}] [${threadid}] ${logger} - ${message}"); } wrapperUnity.QueueLimit = 5000; wrapperUnity.OverflowAction = AsyncTargetWrapperOverflowAction.Grow; if (isClassLogger) { NLogger = Unity.Common.LogUtil.GetLogger(null, (cfg) => { cfg.AddTarget("asyncFile", wrapper); cfg.AddTarget("asyncConsole", wrapperUnity); cfg.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, wrapperUnity); cfg.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Fatal, wrapper); }); } else { NLogger = Unity.Common.LogUtil.GetLogger(appName, (cfg) => { cfg.AddTarget("asyncFile", wrapper); cfg.AddTarget("asyncConsole", wrapperUnity); cfg.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, wrapperUnity); cfg.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Fatal, wrapper); }); } #endif }
public BmpMain() { InitializeComponent(); this.UpdatePerformance(); BmpUpdate update = new BmpUpdate(); if (!Program.programOptions.DisableUpdate) { updateResult = update.ShowDialog(); if (updateResult == DialogResult.Yes) { updateTitle = update.version.updateTitle; updateText = update.version.updateText; updateResult = DialogResult.Yes; } if (updateResult == DialogResult.Ignore) { string log = " This is a preview of a future version of BMP! Please be kind and report any bugs or unexpected behaviors to discord channel."; ChatLogAll.AppendRtf(BmpChatParser.FormatRtf(log, Color.LightYellow, true)); } if (!string.IsNullOrEmpty(update.version.updateLog)) { string log = string.Format("= BMP Update =\n {0} \n", update.version.updateLog); ChatLogAll.AppendRtf(BmpChatParser.FormatRtf(log, Color.LightGreen, true)); } } this.Text = update.version.ToString(); // Clear local orchestra InfoTabs.TabPages.Remove(localOrchestraTab); LocalOrchestra.onMemoryCheck += delegate(Object o, bool status) { if (status) { this.FFXIV.memory.StopThread(); } else { this.FFXIV.memory.StartThread(); } }; FFXIV.findProcessRequest += delegate(Object o, EventArgs empty) { this.Invoke(t => t.FindProcess()); }; FFXIV.findProcessError += delegate(Object o, BmpHook.ProcessError error) { this.Invoke(t => t.ErrorProcess(error)); }; FFXIV.hotkeys.OnFileLoad += delegate(Object o, EventArgs empty) { this.Invoke(t => t.Hotkeys_OnFileLoad(FFXIV.hotkeys)); }; FFXIV.hook.OnKeyPressed += Hook_OnKeyPressed; FFXIV.memory.OnProcessReady += delegate(object o, Process proc) { this.Log(string.Format("[{0}] Process scanned and ready.", proc.Id)); if (Sharlayan.Reader.CanGetActors()) { if (!Sharlayan.Reader.CanGetCharacterId()) { this.Log("[MEMORY] Cannot get Character ID.\n Key bindings won't be loaded, load it manually by selecting an ID in the bottom right."); } if (!Sharlayan.Reader.CanGetChatInput()) { this.Log("[MEMORY] Cannot get chat input status.\n Automatic pausing when chatting won't work."); } if (!Sharlayan.Reader.CanGetPerformance()) { this.Log("[MEMORY] Cannot get performance status.\n Performance detection will not work. Force it to work by ticking Settings > Force playback."); } } else { List <Sharlayan.Models.Signature> signatures = Sharlayan.Signatures.Resolve().ToList(); int sigCount = signatures.Count; foreach (Sharlayan.Models.Signature sig in signatures) { if (Sharlayan.Scanner.Instance.Locations.ContainsKey(sig.Key)) { sigCount--; } else { Console.WriteLine(string.Format("Could not find signature {0}", sig.Key)); } } if (sigCount == signatures.Count) { this.Log(string.Format("[MEMORY] Cannot read memory ({0}/{1}). Functionality will be severely limited.", sigCount, signatures.Count)); this.Invoke(t => t.ErrorProcess(BmpHook.ProcessError.ProcessNonAccessible)); } else { this.Log("[MEMORY] Cannot read actors. Local performance will be broken."); } } }; FFXIV.memory.OnProcessLost += delegate(object o, EventArgs arg) { this.Log("Attached process exited."); }; FFXIV.memory.OnChatReceived += delegate(object o, ChatLogItem item) { this.Invoke(t => t.Memory_OnChatReceived(item)); }; FFXIV.memory.OnPerformanceChanged += delegate(object o, List <uint> ids) { this.Invoke(t => t.LocalOrchestraUpdate((o as FFXIVMemory).GetActorItems(ids))); }; FFXIV.memory.OnPerformanceReadyChanged += delegate(object o, bool performance) { this.Invoke(t => t.Memory_OnPerformanceReadyChanged(performance)); }; FFXIV.memory.OnCurrentPlayerJobChange += delegate(object o, CurrentPlayerResult res) { this.Invoke(t => t.Memory_OnCurrentPlayerJobChange(res)); }; FFXIV.memory.OnCurrentPlayerLogin += delegate(object o, CurrentPlayerResult res) { string world = string.Empty; if (Sharlayan.Reader.CanGetWorld()) { world = Sharlayan.Reader.GetWorld(); } if (string.IsNullOrEmpty(world)) { this.Log(string.Format("Character [{0}] logged in.", res.CurrentPlayer.Name)); } else { this.Log(string.Format("Character [{0}] logged in at [{1}].", res.CurrentPlayer.Name, world)); } if (!Program.programOptions.DisableUpdate) { BmpDonationChecker don = new BmpDonationChecker(res.CurrentPlayer.Name, world); don.OnDonatorResponse += delegate(Object obj, BmpDonationChecker.DonatorResponse donres) { if (donres.donator) { if (!string.IsNullOrEmpty(donres.donationMessage)) { this.Log(donres.donationMessage); } } this.Invoke(t => t.DonationStatus = donres.donator); }; } this.Invoke(t => t.UpdatePerformance()); }; FFXIV.memory.OnCurrentPlayerLogout += delegate(object o, CurrentPlayerResult res) { string format = string.Format("Character [{0}] logged out.", res.CurrentPlayer.Name); this.Log(format); }; FFXIV.memory.OnPartyChanged += delegate(object o, PartyResult res) { this.Invoke(t => t.LocalOrchestraUpdate()); }; Player.OnStatusChange += delegate(object o, PlayerStatus status) { this.Invoke(t => t.UpdatePerformance()); }; Player.OnSongSkip += OnSongSkip; Player.OnMidiProgressChange += OnPlayProgressChange; Player.OnMidiStatusChange += OnPlayStatusChange; Player.OnMidiStatusEnded += OnPlayStatusEnded; Player.OnMidiNote += OnMidiVoice; Player.OffMidiNote += OffMidiVoice; Player.Player.OpenInputDevice(Settings.GetMidiInput().name); Settings.OnMidiInputChange += delegate(object o, MidiInput input) { Player.Player.CloseInputDevice(); if (input.id != -1) { Player.Player.OpenInputDevice(input.name); Log(string.Format("Switched to {0} ({1})", input.name, input.id)); } }; Settings.OnKeyboardTest += delegate(object o, EventArgs arg) { foreach (FFXIVKeybindDat.Keybind keybind in FFXIV.hotkeys.GetPerformanceKeybinds()) { FFXIV.hook.SendSyncKeybind(keybind); Thread.Sleep(100); } }; Settings.OnForcedOpen += delegate(object o, bool open) { this.Invoke(t => { if (open) { Log(string.Format("Forced playback was enabled. You will not be able to use keybinds, such as spacebar.")); WarningLog("Forced playback enabled."); } t.UpdatePerformance(); }); }; Explorer.OnBrowserVisibleChange += delegate(object o, bool visible) { MainTable.SuspendLayout(); MainTable.RowStyles[MainTable.GetRow(ChatPlaylistTable)].Height = visible ? 0 : 100; MainTable.RowStyles[MainTable.GetRow(ChatPlaylistTable)].SizeType = visible ? SizeType.Absolute : SizeType.Percent; //ChatPlaylistTable.Invoke(t => t.Visible = !visible); MainTable.RowStyles[MainTable.GetRow(Explorer)].Height = visible ? 100 : 30; MainTable.RowStyles[MainTable.GetRow(Explorer)].SizeType = visible ? SizeType.Percent : SizeType.Absolute; MainTable.ResumeLayout(true); }; Explorer.OnBrowserSelect += Browser_OnMidiSelect; Playlist.OnMidiSelect += Playlist_OnMidiSelect; Playlist.OnPlaylistRequestAdd += Playlist_OnPlaylistRequestAdd; Playlist.OnPlaylistManualRequestAdd += Playlist_OnPlaylistManualRequestAdd; this.ResizeBegin += (s, e) => { LocalOrchestra.SuspendLayout(); }; this.ResizeEnd += (s, e) => { LocalOrchestra.ResumeLayout(true); }; if (Properties.Settings.Default.SaveLog) { FileTarget target = new NLog.Targets.FileTarget("chatlog") { FileName = "logs/ff14log.txt", Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} ${message}", ArchiveDateFormat = "${shortdate}", ArchiveEvery = FileArchivePeriod.Day, ArchiveFileName = "logs/ff14log-${shortdate}.txt", Encoding = Encoding.UTF8, KeepFileOpen = true, }; var config = new NLog.Config.LoggingConfiguration(); config.AddRule(LogLevel.Info, LogLevel.Info, target); NLog.LogManager.Configuration = config; } string upath = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoaming).FilePath; //Console.WriteLine(string.Format(".config: [{0}]", upath)); Settings.RefreshMidiInput(); Log("Bard Music Player initialized."); }