/// <summary> /// Initializes a new instance of the <see cref="SumoLogicTargetTest"/> class. /// </summary> public SumoLogicTargetTest() { this.messagesHandler = new MockHttpMessageHandler(); this.sumoLogicTarget = new SumoLogicTarget(null, this.messagesHandler); this.sumoLogicTarget.Url = "http://www.fakeadress.com"; this.sumoLogicTarget.Layout = @"${level:upperCase=true}: ${message}"; this.sumoLogicTarget.SourceName = "SumoLogicTargetTest"; this.sumoLogicTarget.Name = "SumoLogicTargetTest"; if (LogManager.Configuration == null) { LogManager.Configuration = new LoggingConfiguration(); } LogManager.Configuration.AddTarget(this.sumoLogicTarget.SourceName, this.sumoLogicTarget); LoggingRule rule = new LoggingRule("SumoLogicTargetTest", LogLevel.Debug, this.sumoLogicTarget); LogManager.Configuration.LoggingRules.Add(rule); LogManager.Configuration.Reload(); LogManager.ReconfigExistingLoggers(); this.logger = LogManager.GetLogger("SumoLogicTargetTest"); }
/// <summary> /// Initializes a new instance of the <see cref="SumoLogicTargetTest"/> class. /// </summary> public SumoLogicTargetTest() { messagesHandler = new MockHttpMessageHandler(); sumoLogicTarget = new SumoLogicTarget(null, messagesHandler); sumoLogicTarget.Url = "http://www.fakeadress.com"; sumoLogicTarget.Layout = @"${level:upperCase=true}: ${message}${exception:format=tostring}${newline}"; sumoLogicTarget.SourceName = "SumoLogicTargetTest"; sumoLogicTarget.SourceCategory = "SumoLogicTargetSourceCategory"; sumoLogicTarget.SourceHost = "${machinename}"; sumoLogicTarget.Name = "SumoLogicTargetTest"; if (LogManager.Configuration == null) { LogManager.Configuration = new LoggingConfiguration(); } LogManager.Configuration.AddTarget(sumoLogicTarget.SourceName, sumoLogicTarget); LoggingRule rule = new LoggingRule("SumoLogicTargetTest", LogLevel.Debug, sumoLogicTarget); LogManager.Configuration.LoggingRules.Add(rule); LogManager.Configuration.Reload(); LogManager.ReconfigExistingLoggers(); logger = LogManager.GetLogger("SumoLogicTargetTest"); }
private static void SetupNLog() { if (File.Exists(Path.Combine(BaseDirectory, "Nlog.config"))) { return; } var config = new LoggingConfiguration(); var loglevel = LogLevel.Info; var layout = @"${message}"; var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); consoleTarget.Layout = layout; var rule1 = new LoggingRule("*", loglevel, consoleTarget); config.LoggingRules.Add(rule1); LogManager.Configuration = config; }
// Настройка логгера public static void LoggerConfig() { LoggingConfiguration config = new LoggingConfiguration(); FileTarget fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); fileTarget.DeleteOldFileOnStartup = true; // Удалатья страый файл при запуске fileTarget.KeepFileOpen = false; //Держать файл открытым fileTarget.ConcurrentWrites = true; // fileTarget.Encoding = Encoding.Unicode; // Кодировка файла логгера fileTarget.ArchiveEvery = FileArchivePeriod.Day; // Период архивирования старых логов fileTarget.Layout = NLog.Layouts.Layout.FromString("${longdate} | ${uppercase:${level}} | ${message}"); // Структура сообщения fileTarget.FileName = NLog.Layouts.Layout.FromString("${basedir}/logs/${shortdate}.log"); //Структура названия файлов fileTarget.ArchiveFileName = NLog.Layouts.Layout.FromString("${basedir}/logs/archives/{shortdate}.rar"); // Структура названия архивов LoggingRule ruleFile = new LoggingRule("*", LogLevel.Trace, fileTarget); // Минимальный уровень логгирования - Trace config.LoggingRules.Add(ruleFile); LogManager.Configuration = config; }
private static void ConfigureConsoleLogger() { var config = new LoggingConfiguration(); if (HasFlags("CERTES_DEBUG")) { config.LoggingRules.Add( new LoggingRule("*", LogLevel.Debug, new ColoredConsoleTarget { Layout = "${message}${onexception:${newline}${exception:format=tostring}}", })); } else { var consoleRule = new LoggingRule("*", LogLevel.Info, new ColoredConsoleTarget { Layout = "${message}", }); config.LoggingRules.Add(consoleRule); } LogManager.Configuration = config; }
public virtual Logger InitLog(string logfileName, string logLayoutFormat) { if (string.IsNullOrEmpty(logLayoutFormat)) { return(this.InitLog(logfileName)); } LoggingConfiguration configuration = new LoggingConfiguration(); FileTarget target = new FileTarget(); configuration.RemoveTarget("file"); configuration.AddTarget("file", target); target.FileName = string.Format("{0}.txt", Path.Combine(Path.GetDirectoryName(logfileName), Path.GetFileNameWithoutExtension(logfileName))); target.Layout = logLayoutFormat; LoggingRule item = new LoggingRule("*", NLog.LogLevel.Trace, target); configuration.LoggingRules.Clear(); configuration.LoggingRules.Add(item); LogManager.Configuration = configuration; Logger logger = this._NLoger = LogManager.GetLogger(logfileName); this.AddNewLineLayOut(); return(this._NLoger = logger); }
public Logger GetFileTargetLogger(string name) { lock (lockObject) { if (LogManager.Configuration == null) { HandleNullConfiguration(); } name = name.ToLowerInvariant(); Logger existing = GetLoggers().FirstOrDefault(e => e.Name == name); if (existing != null) { return(existing); } string fileName = Path.Combine(new[] { LogDir, name + ".log" }); FileInfo info = new FileInfo(fileName); if (!info.Directory.Exists) { Directory.CreateDirectory(info.Directory.FullName); } FileTarget target = TargetFactory.GetDefaultFileTarget(name, fileName); LoggingRule rule = new LoggingRule(name, LogLevel, target); LogManager.Configuration.LoggingRules.Add(rule); LogManager.Configuration.AddTarget(target); LogManager.ReconfigExistingLoggers(); return(GetLoggers().FirstOrDefault(e => e.Name == name)); } }
//the Code has to be part of the main Class / mainmethod /* * using NLog; * MainWindow() { * LoggingConfig.Initialize(); * } * private static Logger log = LogManager.GetCurrentClassLogger(); * log.Debug("This Text will be logged"); //LogExample */ public static void Initialize() { LoggingConfiguration logConfig = new LoggingConfiguration(); FileTarget fileTarget = new FileTarget(); logConfig.AddTarget("file", fileTarget); fileTarget.FileName = "AutoSF.log"; fileTarget.ArchiveOldFileOnStartup = true; fileTarget.ArchiveFileName = "AutoSF.{#}.log"; fileTarget.ArchiveNumbering = ArchiveNumberingMode.Rolling; fileTarget.MaxArchiveFiles = 7; fileTarget.ConcurrentWrites = true; fileTarget.KeepFileOpen = false; fileTarget.Layout = @"${date:format=HH\:mm\:ss.fff} [${level}] ${logger} - ${message}"; LoggingRule rule = new LoggingRule("*", LogLevel.Debug, fileTarget); logConfig.LoggingRules.Add(rule); //Adds output to Console ConsoleTarget consoleTarget = new ConsoleTarget(); logConfig.AddTarget("console", consoleTarget); consoleTarget.Layout = @"${date:format=HH\:mm\:ss.fff} [${level}] ${logger} - ${message}"; rule = new LoggingRule("*", LogLevel.Debug, consoleTarget); logConfig.LoggingRules.Add(rule); LogManager.Configuration = logConfig; //LogManager.DisableLogging(); if (Environment.GetCommandLineArgs().Contains("debug")) //only logs when debug is added as parameter. { LogManager.EnableLogging(); } }
private static void configureLogger(string allEntriesFileName, string errorEntriesFileName) { string layoutFormat = @"${date:format=yyyyMMdd HH\:mm\:ss} ${logger}.${level} ${message}"; var config = new LoggingConfiguration(); var allEntriesFileTarget = new FileTarget(); allEntriesFileTarget.FileName = allEntriesFileName; allEntriesFileTarget.Layout = layoutFormat; config.AddTarget("file", allEntriesFileTarget); var errorEntriesFileTarget = new FileTarget(); errorEntriesFileTarget.FileName = errorEntriesFileName; errorEntriesFileTarget.Layout = layoutFormat; config.AddTarget("file", errorEntriesFileTarget); MethodCallTarget methodTarget = new MethodCallTarget(); methodTarget.ClassName = typeof(LogEventBroadcaster).AssemblyQualifiedName; methodTarget.MethodName = "log"; methodTarget.Parameters.Add(new MethodCallParameter("${message}")); config.AddTarget("broadcaster", methodTarget); var rule1 = new LoggingRule("*", LogLevel.Info, methodTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", LogLevel.Trace, allEntriesFileTarget); config.LoggingRules.Add(rule2); var rule3 = new LoggingRule("*", LogLevel.Warn, errorEntriesFileTarget); config.LoggingRules.Add(rule3); LogManager.Configuration = config; }
public void ApplicationLog() { var config = new LoggingConfiguration(); var loglevel = LogLevel.Debug; var layout = @"${message}"; var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); consoleTarget.Layout = layout; var rule1 = new LoggingRule("*", loglevel, consoleTarget); config.LoggingRules.Add(rule1); LogManager.Configuration = config; var l = LogManager.GetLogger("foo"); var sysLog = @"D:\SynologyDrive\EventLogs\HP_Spec\Application.evtx"; var total = 0; using (var fs = new FileStream(sysLog, FileMode.Open, FileAccess.Read)) { var es = new EventLog(fs); foreach (var eventRecord in es.GetEventRecords()) // l.Info($"Record: {eventRecord}"); { eventRecord.ConvertPayloadToXml(); } } l.Info($"Total: {total}"); }
private static void Add(Assembly assembly) { if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); } try { var metadata = assembly.GetMetadata(); var @namespace = assembly.GetName().Name; if (string.IsNullOrEmpty(metadata?.SentryKey) || string.IsNullOrEmpty(metadata?.SentryProject)) { Log.Info($"Skipped ({@namespace}) missing SentryKey or SentryProject"); return; } var target = new SentryTarget(assembly, metadata); var rule = new LoggingRule($"{@namespace}*", LogLevel.Trace, target) { Final = true }; Targets[assembly] = target; Config.AddTarget(@namespace, target); Config.LoggingRules.Add(rule); Log.Info($"SentryTarget({@namespace})"); LogManager.ReconfigExistingLoggers(); } catch (Exception e) { Log.Error(e); } }
static Log() { 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}"; #if DEBUG //string fileName = "${basedir}/PersistentWindows.Log"; string fileName = "PersistentWindows.Log"; #else string tempFolderPath = Path.GetTempPath(); string fileName = $"{tempFolderPath}/PersistentWindows.Log"; #endif File.Delete(fileName); fileTarget.FileName = fileName; fileTarget.Layout = "${date:format=HH\\:mm\\:ss} ${logger} ${message}"; // Step 4. Define rules var rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", LogLevel.Trace, fileTarget); config.LoggingRules.Add(rule2); // Step 5. Activate the configuration LogManager.Configuration = config; }
/// <summary> /// The method triggered when the command line arguments are parsed /// with success. /// </summary> /// <param name="options"> /// An instance of <see cref="Options" /> containing the parsed command /// line arguments. /// </param> private static void CommandLineArgumentsParsed(Options options) { // Create our StructureMap registry and... Registry registry = new Registry(); Container container = new Container(registry); string logLevelStr = options.Verbosity.ToString(); LogLevel logLevel = LogLevel.FromString(logLevelStr); // Get the default NLog configuration - i.e. the one declared // in Nlog.config. LoggingConfiguration loggingConfiguration = LogManager.Configuration; // Add a rule for each target, based on the input Verbosity level. LoggingRule loggingRule = null; foreach (Target target in loggingConfiguration.AllTargets) { loggingRule = new LoggingRule("*", logLevel, target); loggingConfiguration.LoggingRules.Add(loggingRule); } // Get an instance. IOutputFileGenerator outputFileGenerator = container.GetInstance <IOutputFileGenerator>(); executionSuccess = outputFileGenerator.CreateOutputFile( new Tuple <string, string>( options.AccessKeyId, options.SecretAccessKey), options.AwsRegion, options.PasswordEncryptionKeyFile, options.RoleArn, options.OutputFile); }
private static Logger ConfigureLogger(LogLevel level) { var config = new LoggingConfiguration(); var elasticTarget = new DataDogTarget { // IMPORTANT! replace "YOUR API KEY" with your DataDog API key ApiKey = "YOUR API KEY", Service = Assembly.GetExecutingAssembly()?.GetName().Name, Source = Environment.MachineName }; var rule = new LoggingRule("*", elasticTarget); rule.EnableLoggingForLevel(level); config.AddTarget(elasticTarget); config.LoggingRules.Add(rule); var consoleTarget = new ConsoleTarget("console"); var consoleRule = new LoggingRule("*", consoleTarget); consoleRule.EnableLoggingForLevel(level); config.AddTarget(consoleTarget); config.LoggingRules.Add(consoleRule); var debugTarget = new DebugTarget("debug"); var debugRule = new LoggingRule("*", debugTarget); debugRule.EnableLoggingForLevel(level); config.AddTarget(debugTarget); config.LoggingRules.Add(debugRule); LogManager.Configuration = config; var logger = LogManager.GetLogger("Example"); return(logger); }
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.ArchiveEvery = FileArchivePeriod.Day; 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); // 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 NLogLogProvider() { if (NLog.LogManager.Configuration != null) { return; } var config = new LoggingConfiguration(); #if DEBUG var consoleTarget = new ColoredConsoleTarget() { Layout = @"${level:uppercase=true}|${logger}:${message}${exception}" }; config.AddTarget("console", consoleTarget); var rule1 = new LoggingRule("*", NLog.LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule1); #endif var loggerDir = Path.GetDirectoryName(Assembly.GetCallingAssembly().Location); var fileTarget = new FileTarget() { FileName = Path.Combine(loggerDir, "nlog.log"), Layout = "${longdate}|${level:uppercase=true}:${message}${exception:format=toString}", KeepFileOpen = false, ArchiveFileName = Path.Combine(loggerDir, "nlog.{#####}.log"), ArchiveAboveSize = 4096000, ArchiveNumbering = ArchiveNumberingMode.Sequence, MaxArchiveFiles = 2 }; config.AddTarget("file", fileTarget); var rule2 = new LoggingRule("*", NLog.LogLevel.Debug, fileTarget); config.LoggingRules.Add(rule2); NLog.LogManager.Configuration = config; }
public LogService() { var physicalPath = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath; var logPath = string.Concat(physicalPath, "Durra logs"); if (!Directory.Exists(logPath)) { Directory.CreateDirectory(logPath); } TargetName = "Durra"; var template = new StringBuilder("-------------- ${level} (${longdate}) --------------${newline}"); template.Append("${newline}"); template.Append("Call Site: ${callsite}${newline}"); template.Append("Exception Type: ${exception:format=Type}${newline}"); template.Append("Exception Message:${exception:format=Message}${newline}"); template.Append("Stack Trace: ${exception:format=StackTrace}${newline}"); template.Append("Additional Info: ${message}${newline}"); var target = new FileTarget(); target.Name = TargetName; target.FileName = $"{logPath}\\{Guid.NewGuid()}.log"; target.Layout = template.ToString(); var config = new LoggingConfiguration(); config.AddTarget(TargetName, target); var rule = new LoggingRule("*", LogLevel.Trace, target); config.LoggingRules.Add(rule); LogManager.Configuration = config; _siteLogger = LogManager.GetLogger(TargetName); }
public NLogFactory(string logsFolderPath = "logs") { string assemblyFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); if (string.IsNullOrWhiteSpace(logsFolderPath)) { logsFolderPath = assemblyFolder; } if (File.Exists("NLog.config")) { NLog.LogManager.Configuration = new NLog.Config.XmlLoggingConfiguration(assemblyFolder + "\\NLog.config", true); } else { var config = new LoggingConfiguration(); var fileTarget = new FileTarget(); config.AddTarget("default", fileTarget); if (string.IsNullOrWhiteSpace(logsFolderPath)) { logsFolderPath = "logs"; } fileTarget.FileName = "${basedir}/" + logsFolderPath + "/log_${shortdate}.log"; fileTarget.Layout = @"${longdate} ${level} -- ${message}"; fileTarget.Encoding = Encoding.UTF8; var rule2 = new LoggingRule("default", NLog.LogLevel.Trace, fileTarget); config.LoggingRules.Add(rule2); LogManager.Configuration = config; } Default = GetLogger("default"); }
private static void Initialize() { if (_isInitialized == false) { // Step 1. Create configuration object _config = new LoggingConfiguration(); FileTarget fileTarget = new FileTarget(); _config.AddTarget("file", fileTarget); string path = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath; // set the file fileTarget.FileName = path + string.Format("\\{0}-Log.txt", Guid.NewGuid()); fileTarget.Layout = "${date:format=HH\\:MM\\:ss}: ${message}"; // don’t clutter the hard drive fileTarget.DeleteOldFileOnStartup = true; // Step 4. Define rules LoggingRule rule1 = new LoggingRule("*", LogLevel.Fatal, fileTarget); _config.LoggingRules.Add(rule1); LoggingRule rule2 = new LoggingRule("*", LogLevel.Debug, fileTarget); _config.LoggingRules.Add(rule2); LoggingRule rule3 = new LoggingRule("*", LogLevel.Error, fileTarget); _config.LoggingRules.Add(rule3); // Step 5. Activate the configuration LogManager.Configuration = _config; _logger = LogManager.GetLogger("ScutexServiceLogger"); _isInitialized = true; } }
public void Usn() { var config = new LoggingConfiguration(); var loglevel = LogLevel.Trace; var layout = @"${message}"; var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); consoleTarget.Layout = layout; var rule1 = new LoggingRule("*", loglevel, consoleTarget); config.LoggingRules.Add(rule1); // LogManager.Configuration = config; var usn4 = UsnFile.Load(@"D:\SynologyDrive\ntfs\Troy\J-stream-testing\noname.bin"); // var usn4 = UsnFile.Load(@"D:\!downloads\J-stream-testing\$J"); usn4.UsnEntries.Count.Should().Be(328539); }
public void SetUp() { clientMock = new Mock <IElmahioAPI>(); messagesMock = new Mock <IMessages>(); clientMock.Setup(x => x.Messages).Returns(messagesMock.Object); var target = new ElmahIoTarget(clientMock.Object) { ApiKey = "ApiKey", LogId = Guid.NewGuid().ToString(), Layout = "${longdate}|${level:uppercase=true}|${logger}|${message}", }; var config = new LoggingConfiguration(); config.AddTarget("elmah.io", target); var rule = new LoggingRule("*", LogLevel.Info, target); config.LoggingRules.Add(rule); LogManager.Configuration = config; logger = LogManager.GetLogger("Test"); }
private void SetupVerboseLogging(string logOutputDirFullPath) { logOutputDirFullPath = Path.Combine(logOutputDirFullPath, "Verbose"); var currentLogDir = Path.Combine(logOutputDirFullPath); if (!Directory.Exists(currentLogDir)) { Directory.CreateDirectory(currentLogDir); } var archiveLogDir = Path.Combine(currentLogDir, "Archive"); if (!Directory.Exists(archiveLogDir)) { Directory.CreateDirectory(archiveLogDir); } MoveOldLogToArchive(currentLogDir, archiveLogDir); TrimOlgLogFiles(archiveLogDir, maxMegabytes: 50); var currentFileName = Time.Get.LocalNow.ToString("yyy-MM-dd_HH-mm-ss-ffffff") + ".txt"; currentVerboseLogFileFullPath = Path.Combine(currentLogDir, currentFileName); var fileTarget = new FileTarget { ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, KeepFileOpen = true, FileName = GetCurrentVerboseLogFileFullPath(), Layout = "${date:universalTime=true}|${level}|${logger}|${message}${onexception:inner=|${exception:format=ToString}}" }; var globalrule = new LoggingRule("*", LogLevel.Debug, fileTarget); config.LoggingRules.Add(globalrule); }
public void SimpleJsonLayoutTest() { var elasticTarget = new ElasticSearchTarget(); elasticTarget.EnableJsonLayout = true; elasticTarget.Layout = new JsonLayout() { MaxRecursionLimit = 10, IncludeAllProperties = true, Attributes = { new JsonAttribute("timestamp", "${date:universaltime=true:format=o}"), new JsonAttribute("lvl", "${level}"), new JsonAttribute("msg", "${message}"), new JsonAttribute("logger", "${logger}"), new JsonAttribute("threadid", "${threadid}", false), // Skip quotes for integer-value } }; var rule = new LoggingRule("*", elasticTarget); rule.EnableLoggingForLevel(LogLevel.Info); var config = new LoggingConfiguration(); config.LoggingRules.Add(rule); LogManager.ThrowExceptions = true; LogManager.Configuration = config; var logger = LogManager.GetLogger("Example"); logger.Info("Hello elasticsearch"); LogManager.Flush(); }
internal void SetupLogger() { try { var logConfig = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); var fileTarget = new FileTarget(); var highlightRuleInfo = new ConsoleRowHighlightingRule { Condition = ConditionParser.ParseExpression("level == LogLevel.Info"), ForegroundColor = ConsoleOutputColor.DarkGreen }; consoleTarget.RowHighlightingRules.Add(highlightRuleInfo); consoleTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger:shortName=true} | ${level:uppercase=true:padding=-5} | ${message}"; fileTarget.FileName = Path.Combine(_logDirectory, $"{DateTime.UtcNow.ToString("yyyy-MM-dd")}.log"); fileTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger:shortName=true} | ${level:uppercase=true:padding=-5} | ${message}"; logConfig.AddTarget("console", consoleTarget); logConfig.AddTarget("file", fileTarget); var rule1 = new LoggingRule("*", NLog.LogLevel.Info, consoleTarget); logConfig.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", NLog.LogLevel.Info, fileTarget); logConfig.LoggingRules.Add(rule2); LogManager.Configuration = logConfig; } catch (Exception ex) { Console.WriteLine(ex); } }
public FileLoggingConfigurator(string targetName, string[] namePatterns, string defaultFilePath) { _target = new FileTarget { Name = targetName, }; _target.FileName = defaultFilePath; _rules = new LoggingRule[namePatterns.Length]; for (var i = 0; i < namePatterns.Length; i++) { var rule = new LoggingRule { LoggerNamePattern = namePatterns[i], Final = true, }; rule.Targets.Add(_target); rule.Targets.Add(TorchUtils.GetWpfTarget()); rule.EnableLoggingForLevels(LogLevel.Info, LogLevel.Off); _rules[i] = rule; } }
static ProgramLogger() { var path = Path.Combine(Constant.DataDirectory, DirectoryName, Constant.Version); if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } var configuration = new LoggingConfiguration(); using (var target = new FileTarget()) { configuration.AddTarget("file", target); target.FileName = path.Replace(@"\", "/", StringComparison.Ordinal) + "/${shortdate}.txt"; #if DEBUG var rule = new LoggingRule("*", LogLevel.Debug, target); #else var rule = new LoggingRule("*", LogLevel.Error, target); #endif configuration.LoggingRules.Add(rule); } LogManager.Configuration = configuration; }
private static LoggingRule RegisterAppFile(IAppFolderInfo appFolderInfo, string name, string fileName, int maxArchiveFiles) { var fileTarget = new NzbDroneFileTarget(); fileTarget.Name = name; fileTarget.FileName = Path.Combine(appFolderInfo.GetLogFolder(), fileName); fileTarget.AutoFlush = true; fileTarget.KeepFileOpen = false; fileTarget.ConcurrentWrites = false; fileTarget.ConcurrentWriteAttemptDelay = 50; fileTarget.ConcurrentWriteAttempts = 10; fileTarget.ArchiveAboveSize = 1024000; fileTarget.MaxArchiveFiles = maxArchiveFiles; fileTarget.EnableFileDelete = true; fileTarget.ArchiveNumbering = ArchiveNumberingMode.Rolling; fileTarget.Layout = FILE_LOG_LAYOUT; var loggingRule = new LoggingRule("*", LogLevel.Trace, fileTarget); LogManager.Configuration.AddTarget(name, fileTarget); LogManager.Configuration.LoggingRules.Add(loggingRule); return(loggingRule); }
public static void AddTarget(Target target, LogLevel logLevel) { if (!loggingRules.TryGetValue(logLevel, out LoggingRule lr)) { lr = new LoggingRule(); foreach (var ll in LogLevel.AllLoggingLevels) { if (ll >= logLevel) { lr.EnableLoggingForLevel(ll); } else { lr.DisableLoggingForLevel(ll); } } lr.LoggerNamePattern = "*"; LogConfiguration.LoggingRules.Add(lr); loggingRules[logLevel] = lr; } lr.Targets.Add(target); LogManager.Configuration = LogConfiguration; }
static Log() { CurrentLogDirectory = Path.Combine(Constant.DataDirectory, DirectoryName, Constant.Version); if (!Directory.Exists(CurrentLogDirectory)) { Directory.CreateDirectory(CurrentLogDirectory); } var configuration = new LoggingConfiguration(); var target = new FileTarget(); configuration.AddTarget("file", target); // Adding CurrentCulture since this is user facing target.FileName = CurrentLogDirectory.Replace(@"\", "/", StringComparison.CurrentCulture) + "/${shortdate}.txt"; #if DEBUG var rule = new LoggingRule("*", LogLevel.Debug, target); #else var rule = new LoggingRule("*", LogLevel.Info, target); #endif configuration.LoggingRules.Add(rule); LogManager.Configuration = configuration; target.Dispose(); }
public NLogManager() { var config = new LoggingConfiguration(); var consoleTarget = new ConsoleTarget(); config.AddTarget("console", consoleTarget); var consoleRule = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(consoleRule); var fileTarget = new FileTarget(); string folder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); fileTarget.FileName = Path.Combine(folder, "Log.txt"); config.AddTarget("file", fileTarget); var fileRule = new LoggingRule("*", LogLevel.Warn, fileTarget); config.LoggingRules.Add(fileRule); LogManager.Configuration = config; }
public void Setup() { var config = new LoggingConfiguration(); var loglevel = LogLevel.Debug; var layout = @"${message}"; var cc = new ColoredConsoleTarget(); var tt = new FileTarget(); tt.FileName = @"C:\temp\mftLog.txt"; config.AddTarget("cc", cc); config.AddTarget("tt", tt); cc.Layout = layout; var rule1 = new LoggingRule("*", loglevel, cc); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", loglevel, tt); config.LoggingRules.Add(rule2); LogManager.Configuration = config; Mfts = new Dictionary <string, string>(); // Mfts.Add("controller", @"D:\sync\MFTs\controller\$MFT"); // Mfts.Add("nfury", @"D:\sync\MFTs\nfury\$MFT"); // Mfts.Add("nromanoff", @"D:\sync\MFTs\nromanoff\$MFT"); // Mfts.Add("tdungan", @"..\..\TestFiles\tdungan\$MFT"); Mfts.Add("blake", @"D:\sync\MFTs\blake\$MFT"); // Mfts.Add("other", @"..\..\TestFiles\$MFT"); }
/// <summary> /// Setups the logger with the <see cref="BufferedSumoLogicTarget"/> based on the given settings. /// </summary> /// <param name="messagesPerRequest">The maximum messages per request.</param> /// <param name="maxFlushInterval">The maximum flush interval, in milliseconds.</param> /// <param name="flushingAccuracy">The flushing accuracy, in milliseconds.</param> /// <param name="retryInterval">The retry interval, in milliseconds.</param> private void SetUpLogger(long messagesPerRequest, long maxFlushInterval, long flushingAccuracy, long retryInterval = 10000) { this.messagesHandler = new MockHttpMessageHandler(); this.bufferedSumoLogicTarget = new BufferedSumoLogicTarget(null, this.messagesHandler); this.bufferedSumoLogicTarget.Url = "http://www.fakeadress.com"; this.bufferedSumoLogicTarget.Layout = @"${level:upperCase=true}: ${message}"; this.bufferedSumoLogicTarget.SourceName = "BufferedSumoLogicTargetTest"; this.bufferedSumoLogicTarget.SourceName = "BufferedSumoLogicTargetTest"; this.bufferedSumoLogicTarget.MessagesPerRequest = messagesPerRequest; this.bufferedSumoLogicTarget.MaxFlushInterval = maxFlushInterval; this.bufferedSumoLogicTarget.FlushingAccuracy = flushingAccuracy; this.bufferedSumoLogicTarget.RetryInterval = retryInterval; if (LogManager.Configuration == null) { LogManager.Configuration = new LoggingConfiguration(); } LogManager.Configuration.AddTarget(this.bufferedSumoLogicTarget.SourceName, this.bufferedSumoLogicTarget); LoggingRule rule = new LoggingRule("BufferedSumoLogicTargetTest", LogLevel.Info, this.bufferedSumoLogicTarget); LogManager.Configuration.LoggingRules.Add(rule); LogManager.Configuration.Reload(); LogManager.ReconfigExistingLoggers(); this.logger = LogManager.GetLogger("BufferedSumoLogicTargetTest"); }
private static void SetupNLog() { var config = new LoggingConfiguration(); var loglevel = LogLevel.Info; var layout = @"${message}"; var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); consoleTarget.Layout = layout; var rule1 = new LoggingRule("*", loglevel, consoleTarget); config.LoggingRules.Add(rule1); LogManager.Configuration = config; }