public Task <int> Execute(GenerateParameters parameters) { var mapperConfiguration = new AutoMapperConfiguration(); Mapper.Initialize(mapperConfiguration.Configure); var generator = new Generator( new Random(), parameters.ProductIdMin, parameters.ProductIdMax, parameters.CustomerIdMin, parameters.CustomerIdMax, parameters.RevenueMin, parameters.RevenueMax); var config = new LoggingConfiguration(); var now = DateTime.Now; var logfile = new FileTarget { FileName = $"generated-{now:yyyyMMddHHmmss}.log" }; var logconsole = new ConsoleTarget(); config.AddRule(LogLevel.Info, LogLevel.Fatal, logconsole); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); LogManager.Configuration = config; var logger = LogManager.GetCurrentClassLogger(); var cancellationTokenSource = new CancellationTokenSource(); Task.WaitAll(ToggleSignalStateTaskAsync(parameters, cancellationTokenSource), GeneratorTask(parameters, generator, logger, cancellationTokenSource)); return(Task.FromResult(0)); }
public static void AssemblyInit(TestContext context) { var config = new LoggingConfiguration(); var debuggerTarget = new DebuggerTarget("debugger") { Layout = @"${date:format=HH\:mm\:ss} ${level} ${message} ${exception}" }; config.AddTarget(debuggerTarget); config.AddRuleForAllLevels(debuggerTarget); var consoleTarget = new ConsoleTarget("console") { Layout = @"${date:format=HH\:mm\:ss} ${level} ${message} ${exception}" }; config.AddTarget(consoleTarget); config.AddRuleForAllLevels(consoleTarget); config.AddRule(LogLevel.Fatal, LogLevel.Trace, consoleTarget); LogManager.Configuration = config; IndyDotNet.Utils.Logger.Init(); LogManager.GetCurrentClassLogger().Info("Logging started"); }
private static void LoggerInit() { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var consoleTarget = new ConsoleTarget(); config.AddTarget("console", consoleTarget); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); const string Layout = @"[${date:format=HH\:mm\:ss}] [${level}] ${message} " + "${onexception:${exception:format=tostring,stacktrace}${newline}${stacktrace}}"; // Step 3. Set target properties consoleTarget.Layout = Layout; fileTarget.FileName = "Cruciatus.log"; fileTarget.Layout = Layout; // 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; }
private static LoggingConfiguration ConfigureLogger() { var config = new LoggingConfiguration(); var fileTarget = new FileTarget { Name = "logFile", FileName = @"\\Storage1\Users\garmstrong\RenameLogs\SimpleLog.txt", Layout = "[${level}] ${message}", KeepFileOpen = true, //DeleteOldFileOnStartup = true, }; var consoleTarget = new ConsoleTarget { Name = "logConsole" }; var fileRule = new LoggingRule("logFile", LogLevel.Debug, fileTarget); var consoleRule = new LoggingRule("logConsole", LogLevel.Debug, consoleTarget); config.AddTarget(fileTarget); config.AddTarget(consoleTarget); config.LoggingRules.Add(fileRule); config.LoggingRules.Add(consoleRule); return(config); }
/// <summary> /// Inits logging facility and loggers. /// </summary> private static void InitLoggers() { LogManager.Enabled = true; // enable logger by default. foreach (var targetConfig in LogConfig.Instance.Targets) { if (!targetConfig.Enabled) { continue; } LogTarget target = null; switch (targetConfig.Target.ToLower()) { case "console": target = new ConsoleTarget(targetConfig.MinimumLevel, targetConfig.MaximumLevel, targetConfig.IncludeTimeStamps); break; case "file": target = new FileTarget(targetConfig.FileName, targetConfig.MinimumLevel, targetConfig.MaximumLevel, targetConfig.IncludeTimeStamps, targetConfig.ResetOnStartup); break; } if (target != null) { LogManager.AttachLogTarget(target); } } }
/// <summary> /// This code sets up the different /// logging levels for the mod. /// </summary> private void SetupLogging() { var config = new LoggingConfiguration(); // The layout of the log var layout = "[${time}] [" + Assembly.GetAssembly(typeof(CSM)).GetName().Version.ToString() + "] [${level}] ${message} ${exception:format=tostring}"; // Target for file logging var logfile = new FileTarget("logfile") { FileName = "multiplayer-logs/log-current.txt", ArchiveFileName = "multiplayer-logs/log-${shortdate}.txt", Layout = layout, ArchiveEvery = FileArchivePeriod.Day, MaxArchiveFiles = 7, ConcurrentWrites = true, }; // Target for console logging var logconsole = new ConsoleTarget("logconsole") { Layout = layout }; // While in development set both levels to start at debug, later on we // want to set an option to do this. config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); LogManager.Configuration = config; }
public Bebop() { LoggingConfiguration config = new LoggingConfiguration(); FileTarget logfile = new FileTarget("logfile") { FileName = "BebopFileLog.txt" }; ConsoleTarget consoleLog = new ConsoleTarget("logconsole"); config.AddRule(LogLevel.Info, LogLevel.Fatal, consoleLog); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); LogManager.Configuration = config; Logger = LogManager.GetCurrentClassLogger(); // Set Bebop sensors Sensors = new List <Sensor.Sensor> { Battery, FlyingState, Altitude, FlatTrimChanged, AttitudeChanged }; }
static AppLog() { var fileTarget = new FileTarget("file_log") { Encoding = Encoding.UTF8, LineEnding = LineEndingMode.CRLF, Layout = "${longdate} ${level} ${message} ${exception}", FileName = "${basedir}/Logs/event.log", MaxArchiveFiles = 7, ArchiveEvery = FileArchivePeriod.Day, ArchiveNumbering = ArchiveNumberingMode.Date }; var config = new LoggingConfiguration(); config.AddTarget(fileTarget); config.AddRuleForAllLevels(fileTarget); var consoleTarget = new ConsoleTarget("console_log") { Layout = "${longdate} ${level} ${message} ${exception}", AutoFlush = true, Encoding = Encoding.UTF8 }; config.AddTarget(consoleTarget); config.AddRuleForAllLevels(consoleTarget); LogManager.Configuration = config; Logger = LogManager.GetLogger("DesktopDemo"); }
/// <summary> /// Instantiate a Logger with the specified name and minimum message level /// </summary> /// <param name="name">Name of logger</param> /// <param name="minLevel">Messages of lower level than this will not be logged</param> /// <returns>Logger with appropriate name, minimum level and settings</returns> private Logger GetLogger(string name, NLog.LogLevel minLevel) { string savePath = GetSavePath(); //Generate save path var fileTarget = new FileTarget(); // Create a target var consoleTarget = new ConsoleTarget(); if (String.IsNullOrWhiteSpace(name)) { name = "Log"; } _logConfig.AddTarget($"{name}_file", fileTarget); // Add the target to the configuration _logConfig.AddTarget($"{name}_console", consoleTarget); string time = _logStart.ToString("yyyyMMdd-HHmm"); fileTarget.FileName = $@"{savePath}\{time}_{name}.log"; //set name (and path) of savefile fileTarget.Layout = @"${date} | ${level} | ${message}"; //Define layout for file consoleTarget.Layout = @"${time} | ${level} | ${message}"; var fileRule = new LoggingRule(name, minLevel, fileTarget); //Create logging rules... var consoleRule = new LoggingRule(name, minLevel, consoleTarget); _logConfig.LoggingRules.Add(fileRule); //...and add to configuration _logConfig.LoggingRules.Add(consoleRule); LogManager.Configuration = _logConfig; //Activate the configuration return(LogManager.GetLogger(name)); }
private static void ConfigureStructuredLogging() { try { var config = new LoggingConfiguration(); var consoleTarget = new ConsoleTarget { Layout = new JsonLayout { IncludeAllProperties = true, Attributes = { new JsonAttribute("time", new SimpleLayout("${longdate}")), new JsonAttribute("level", new SimpleLayout("${level}")), new JsonAttribute("message", new SimpleLayout("${message}")), } } }; config.AddRuleForAllLevels(consoleTarget, "*"); LogManager.Configuration = config; } catch (Exception e) { Console.WriteLine("An error occurred while attempting to configure the logger. Exiting."); Console.WriteLine(e.StackTrace); throw; } }
/// <summary> /// Configure logger /// </summary> private static void ConfigureLogger() { var config = new LoggingConfiguration(); // Define layout const string?layout = "${longdate} [Thread-${threadid}] [${level}] ${logger} - ${message}"; // Define target var console = new ConsoleTarget { Layout = layout }; var file = new FileTarget { Layout = layout, FileName = "${basedir}/Logs/application.log", ArchiveFileName = "${basedir}/Logs/application_{#}.log", ArchiveNumbering = ArchiveNumberingMode.Date, ArchiveAboveSize = 1 * 1000 * 1000, // 1Mo MaxArchiveFiles = 3, }; // Add rules #if DEBUG config.AddRule(LogLevel.Trace, LogLevel.Fatal, console); config.AddRule(LogLevel.Trace, LogLevel.Fatal, file); #else config.AddRule(LogLevel.Info, LogLevel.Fatal, console); config.AddRule(LogLevel.Info, LogLevel.Fatal, file); #endif // Apply LogManager.Configuration = config; }
static void СконфигурироватьЛогирование() { var названиеПродукта = Assembly.GetEntryAssembly().GetCustomAttributes(false) .OfType <AssemblyProductAttribute>() .FirstOrDefault() ?.Product; var конфигурация = new LoggingConfiguration(); var файловыйЛог = new FileTarget("логфайл") { FileName = Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), названиеПродукта, "Logs", "log.txt") }; var консольныйЛог = new ConsoleTarget("консольный лог"); Directory.CreateDirectory(Path.GetDirectoryName(файловыйЛог.FileName.ToString().Trim('\''))); конфигурация.AddTarget(файловыйЛог); конфигурация.AddTarget(консольныйЛог); конфигурация.AddRuleForAllLevels(файловыйЛог); конфигурация.AddRuleForAllLevels(консольныйЛог); LogManager.Configuration = конфигурация; }
/// <summary> /// Configures the logger according to <paramref name="args"/>. /// </summary> /// <param name="args"><see cref="ProgramArguments"/></param> private void ConfigLogger(ProgramArguments args) { LogLevel consoleLogLevel = args.Verbose ? LogLevel.Info : LogLevel.Off; var config = new LoggingConfiguration(); // Configure the targets and rules. var consoleTarget = new ConsoleTarget { Layout = "${uppercase:${level}}: ${message} ${exception}" }; config.AddRule(consoleLogLevel, LogLevel.Error, consoleTarget); Directory.CreateDirectory("logs"); var fileTarget = new FileTarget { FileName = Path.Combine("logs", $"{_programData.GameAbbreviation}_Version_Swapper.{DateTime.Now:s}.log"), Layout = "${longdate} | ${stacktrace} | ${uppercase:${level}} | ${message} ${exception}" }; config.AddRule(LogLevel.Debug, LogLevel.Fatal, fileTarget); // Set and load the configuration. LogManager.Configuration = config; LogManager.ReconfigExistingLoggers(); _programData.NLogger.Info("Verbose mode activated."); }
public static void Main(string[] args) { var loggerConfig = new LoggingConfiguration(); var newReliTarget = new ConsoleTarget { Name = "NewRelicTarget", Layout = new NewRelicJsonLayout() }; loggerConfig.AddTarget(newReliTarget); loggerConfig.AddRuleForAllLevels("NewRelicTarget"); LogManager.Configuration = loggerConfig; var logger = LogManager.GetCurrentClassLogger(); try { logger.Debug("init main"); var host = CreateHostBuilder(args).Build(); host.Run(); } catch (Exception ex) { logger.Error(ex, "Stopped program because of exception"); throw; } finally { NLog.LogManager.Shutdown(); } CreateHostBuilder(args).Build().Run(); }
/// <summary> /// Creates new or updates an existing configuration with the console target name "ConsoleTarget". /// It will be like the [target xsi:type="Console" name="ConsoleTarget" layout="${date:universalTime=true:format=HH\:mm\:ss}|${level:uppercase=true}|${message}" ] /// The rule will be set to like [logger name="*" minlevel="Info" writeTo="ConsoleTarget"] /// </summary> /// <param name="nLogSettings">The settings for <see cref="NLogLogger"/>.</param> /// <param name="configuration">The NLog logging configuration.</param> /// <returns></returns> public static LoggingConfiguration GenerateUpdateConsoleLoggingConfiguration(NLogLoggerSettings nLogSettings, LoggingConfiguration configuration = null) { LoggingConfiguration nlogConfiguration = configuration ?? new LoggingConfiguration(); var consoleTarget = new ConsoleTarget(); consoleTarget.Name = nameof(ConsoleTarget); consoleTarget.Layout = @"${date:universalTime=true:format=HH\:mm\:ss}|${level:uppercase=true}|${message}"; nlogConfiguration.RemoveTarget(consoleTarget.Name); nlogConfiguration.AddTarget(consoleTarget.Name, consoleTarget); if (nLogSettings.AcceptedCategoryNames.Count == 0) { var rule = new LoggingRule("*", WrappedNLog.LogLevel.Info, WrappedNLog.LogLevel.Fatal, consoleTarget); nlogConfiguration.LoggingRules.Add(rule); } else { // Create rules for all categories in the settings. foreach (var loggerNamePattern in nLogSettings.AcceptedCategoryNames) { var rule = new LoggingRule(loggerNamePattern, WrappedNLog.LogLevel.Info, WrappedNLog.LogLevel.Fatal, consoleTarget); nlogConfiguration.LoggingRules.Add(rule); } } return(nlogConfiguration); }
private static ILogger GetLogger() { var logConfig = new LoggingConfiguration(); var fileTarget = new FileTarget() { Name = "fileLog", FileName = "${basedir}/Logs/info.log", CreateDirs = true, Layout = "${longdate} Thr: ${threadid} - [${level}] - ${message} ${exception}", ArchiveFileName = $"./Logs/Archives/{DateTime.Now.Day}-{DateTime.Now.Month}-{DateTime.Now.Year}.log", ArchiveOldFileOnStartup = true }; var consoleTarget = new ConsoleTarget("consoleLog") { Layout = @"${date:format=HH\:mm\:ss} [${threadid}] [${level}] - ${message} ${exception}", OptimizeBufferReuse = true }; logConfig.AddTarget(fileTarget); logConfig.AddTarget(consoleTarget); logConfig.AddRuleForAllLevels(fileTarget); logConfig.AddRuleForAllLevels(consoleTarget); LogManager.Configuration = logConfig; return(LogManager.GetCurrentClassLogger()); }
/// <summary> /// Initializes the logger. /// </summary> /// <returns></returns> private static ILogger InitLogger() { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var consoleTarget = new ConsoleTarget(); config.AddTarget("console", consoleTarget); // Step 3. Set target properties consoleTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}"; // Step 4. Define rules #if DEBUG var rule1 = new LoggingRule("*", LogLevel.Debug, consoleTarget); #elif UNIT_TEST var rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget); #else var rule1 = new LoggingRule("*", LogLevel.Warn, consoleTarget); #endif config.LoggingRules.Add(rule1); // Step 5. Activate the configuration LogManager.Configuration = config; // Example usage return(LogManager.GetLogger("VkApi")); }
public static void Setup() { if (LogManager.Configuration == null) { LogManager.Configuration = new LoggingConfiguration(); } else if (LogManager.Configuration.FindTargetByName <ConsoleTarget>(TestLoggerName) != null) { return; } var consoleTarget = new ConsoleTarget(TestLoggerName) { Layout = @"${longdate}|${level}|${logger}|${message}|${exception:format=toString,Data:maxInnerExceptionLevel=5}", AutoFlush = true }; LoggingConfiguration config = LogManager.Configuration; config.AddTarget(consoleTarget); config.AddRuleForAllLevels(consoleTarget); LogManager.GlobalThreshold = LogLevel.Trace; LogManager.GetCurrentClassLogger().Info("TestLogger added to LogManager config"); }
private static void ConfigureNLog() { var config = new LoggingConfiguration(); var fileTarget = new FileTarget { FileName = Path.GetFullPath("CoinbaseSample.log") }; config.AddTarget("logfile", fileTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget)); var consoleTarget = new ConsoleTarget { Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} ${message}" }; config.AddTarget("console", consoleTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, consoleTarget)); LogManager.Configuration = config; LogManager.GetCurrentClassLogger().Info("Log initialized"); Api.SetLogger(new GdaxApiLogger()); }
private static LogFactory GetLogFactory(string[] args, string defaultPath) { string logPath = LogBaseProperties.GetLogPath(args, defaultPath); var logConfig = new LoggingConfiguration(); var target = new FileTarget() { Name = "Def", FileName = logPath, Layout = "${date} ${message} ${onexception:inner=${exception:format=toString}}" }; logConfig.AddTarget(target); logConfig.AddRuleForAllLevels(target); var consoleTarget = new ConsoleTarget { Layout = "${date} ${message} ${onexception:inner=${exception:format=toString}}", Name = "console" }; logConfig.AddTarget(consoleTarget); logConfig.AddRuleForAllLevels(consoleTarget); var logFactory = new LogFactory(logConfig); return(logFactory); }
public void ResolvingTest() { var test = _container.Resolve <TestClass>(); Assert.IsNotNull(test); // Step 1.Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var target = new ConsoleTarget(); config.AddTarget("console", target); // Step 3. Set target properties // Step 4. Define rules LoggingRule rule1 = new LoggingRule("*", LogLevel.Trace, target); config.LoggingRules.Add(rule1); //config.LoggingRules.Remove(rule); // Step 5. Activate the configuration LogManager.Configuration = config; test.Trace(); }
public static void Main(string[] args) { MainConfig app = JsonFileParser.DeserializeFile <MainConfig> ("Config/MainConfig.json"); var cfg = new LoggingConfiguration(); var console = new ConsoleTarget(); console.Layout = @"${level} [${logger}] - ${message}"; cfg.AddTarget("console", console); LogLevel level = DetermineLogLevel(app.LogLevel); cfg.LoggingRules.Add(new LoggingRule("*", level, console)); LogManager.Configuration = cfg; Logger logger = LogManager.GetCurrentClassLogger(); var uri = String.Format("http://localhost:{0}", app.Port); var host = new NancyHost(new Uri(uri)); logger.Info("Listening on {0}", uri); host.Start(); logger.Info("Connecting to zookeeper and registering service..."); ZookeeperAccessor accessor = new ZookeeperAccessor(app.ZookeeperHost, app.ZookeeperPort); accessor.RegisterService("1.0", "location", app.Port, "/location"); accessor.RegisterService("1.0", "time", app.Port, "/time"); logger.Info("Service registration complete"); while (true) { } }
static void Main(string[] args) { LogManager.Configuration = new LoggingConfiguration(); var target = new ConsoleTarget("PinMameSilk"); LogManager.Configuration.AddTarget(target); LogManager.Configuration.AddRule(LogLevel.Info, LogLevel.Fatal, target); LogManager.ReconfigExistingLoggers(); var options = WindowOptions.Default; options.Size = new Vector2D <int>(128 * 6, 32 * 6); options.Title = "PinMAME Silk"; var window = Window.Create(options); DmdController dmdController = null; UIOverlayController uiOverlayController = null; PinMameController pinMameController = null; GL gl = null; window.Load += () => { gl = GL.GetApi(window); var input = window.CreateInput(); dmdController = DmdController.Instance(window); uiOverlayController = UIOverlayController.Instance(window, input, gl); pinMameController = PinMameController.Instance(); // (ImGui needs resize message first) window.Resize += (size) => { size.Y = size.X * 32 / 128; window.Size = size; }; }; window.FramebufferResize += (size) => { gl.Viewport(size); }; window.Render += (delta) => { gl.Clear((uint)ClearBufferMask.ColorBufferBit); gl.ClearColor(1.0f, 1.0f, 0.0f, 1.0f); dmdController.Render(); uiOverlayController.Render(delta); }; window.Run(); }
private static void SetupLogger() { var config = new LoggingConfiguration(); var logconsole = new ConsoleTarget("logconsole"); if (!Directory.Exists("logs")) { Directory.CreateDirectory("logs"); } var logfile = new FileTarget("logfile") { FileName = Directory.GetCurrentDirectory() + "\\logs\\bmlauncher_report__" + CurrentTime + ".log" }; var logDirectory = new DirectoryInfo(Directory.GetCurrentDirectory() + "\\logs"); var oldestAllowedArchive = DateTime.Now - new TimeSpan(3, 0, 0, 0); foreach (FileInfo file in logDirectory.GetFiles()) { if (file.CreationTime < oldestAllowedArchive) { file.Delete(); } } config.AddRule(LogLevel.Debug, LogLevel.Warn, logconsole); config.AddRule(LogLevel.Debug, LogLevel.Warn, logfile); LogManager.Configuration = config; }
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 = Android.OS.Environment.ExternalStorageDirectory.Path; var date = DateTime.UtcNow.Date.ToString("dd.MM.yyyy"); fileTarget.FileName = Path.Combine(folder, "BudgetUnderControl", string.Format("buc-Log-{0}.txt", date)); config.AddTarget("file", fileTarget); var fileRule = new LoggingRule("*", LogLevel.Info, fileTarget); config.LoggingRules.Add(fileRule); LogManager.Configuration = config; }
static async Task Start() { Console.Title = "Samples.SampleWithClean"; #region ConfigureNLog ConfigurationItemFactory.Default.LayoutRenderers .RegisterDefinition("customexception", typeof(CustomExceptionLayoutRenderer)); var config = new LoggingConfiguration(); var layout = "$|${logger}|${message}${onexception:${newline}${customexception:format=tostring}}"; var consoleTarget = new ConsoleTarget { Layout = layout }; config.AddTarget("console", consoleTarget); var consoleRule = new LoggingRule("*", LogLevel.Info, consoleTarget); config.LoggingRules.Add(consoleRule); var fileTarget = new FileTarget { FileName = "log.txt", Layout = layout }; config.AddTarget("file", fileTarget); var fileRule = new LoggingRule("*", LogLevel.Info, fileTarget); config.LoggingRules.Add(fileRule); LogManager.Configuration = config; NServiceBus.Logging.LogManager.Use <NLogFactory>(); var endpointConfiguration = new EndpointConfiguration("Samples.SampleWithClean"); #endregion endpointConfiguration.UseSerialization <JsonSerializer>(); endpointConfiguration.UsePersistence <InMemoryPersistence>(); endpointConfiguration.EnableInstallers(); DisableRetries(endpointConfiguration); #region customization-config var recoverability = endpointConfiguration.Recoverability(); recoverability.Failed(failed => failed.HeaderCustomization(StackTraceCleaner.CleanUp)); #endregion var endpointInstance = await Endpoint.Start(endpointConfiguration) .ConfigureAwait(false); try { await Run(endpointInstance) .ConfigureAwait(false); } finally { await endpointInstance.Stop() .ConfigureAwait(false); } }
private static void Main(string[] args) { // Configure NLog. var nlogConfig = new LoggingConfiguration(); var fileTarget = new FileTarget("file") { FileName = "nlog.log", KeepFileOpen = true, ConcurrentWrites = false }; nlogConfig.AddTarget(fileTarget); nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget)); var consoleTarget = new ConsoleTarget("console"); nlogConfig.AddTarget(consoleTarget); nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, consoleTarget)); // Configure PostSharp Logging to use NLog. LoggingServices.DefaultBackend = new NLogLoggingBackend(new LogFactory(nlogConfig)); LogManager.EnableLogging(); // Simulate some business logic. QueueProcessor.ProcessQueue(@".\Private$\SyncRequestQueue"); }
public static void SetupLog() { var configuration = new LoggingConfiguration(); var console = new ConsoleTarget { Layout = @"${date}|${level:uppercase=true}|${message} ${exception}|${logger}|${all-event-properties}" }; var file = new FileTarget { FileName = Path.Combine(Directory.GetCurrentDirectory(), "logs", "log.log"), Layout = @"${date}|${level:uppercase=true}|${message} ${exception}|${logger}|${all-event-properties}", ArchiveEvery = FileArchivePeriod.Day, ArchiveFileName = Path.Combine(Directory.GetCurrentDirectory(), "logs", DateTime.Now.ToString("yyyyMMdd") + ".log") }; configuration.AddTarget("Console", console); configuration.AddTarget("File", file); configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, console)); configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, file)); LogManager.Configuration = configuration; }
/// <summary> /// Configure NLog. /// </summary> /// <remarks> /// Level < 0 --> Clear Config /// Level = 0 --> Do nothing /// Level = 1 --> Debug /// Leven > 1 --> Trace /// </remarks> /// <param name="level"></param> public static void ConfigureLogging(int level) { if (level < 0) { // Need to reset configuration to null for NLog 2.0 on mono // so we don't hang on exit. LogManager.Configuration = null; return; } if (level == 0) { return; } if (LogManager.Configuration != null && LogManager.Configuration.LoggingRules.Count > 0) { Console.WriteLine("Logging was configured by a .config file, not changing the configuration."); return; } var nconfig = new LoggingConfiguration(); var consoleTarget = new ConsoleTarget(); nconfig.AddTarget("console", consoleTarget); consoleTarget.Layout = "${logger} ${message}"; var rule = new LoggingRule("*", level == 1 ? LogLevel.Debug : LogLevel.Trace, consoleTarget); nconfig.LoggingRules.Add(rule); LogManager.Configuration = nconfig; }
public void AddConsoleOutput() { DebugFileWriter( LogDirectory, String.Format( "AddConsoleOutput called." )); RemoveTarget("ConsoleTargetWrapper"); var wrapper = new AsyncTargetWrapper(); wrapper.Name = "ConsoleTargetWrapper"; var target = new ConsoleTarget() { Layout = "${level}, ${logger}, ${message}", Error = false }; target.Name = "ConsoleTarget"; wrapper.WrappedTarget = target; AddLogTarget(wrapper, LogSeverity); }
protected virtual void SetupLogging() { var config = new LoggingConfiguration(); var consoleTarget = new ConsoleTarget(); consoleTarget.Layout = @"${message}"; config.AddTarget("console", consoleTarget); var rule = new LoggingRule("*", NLog.LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule); NLog.LogManager.Configuration = config; LogManager.Adapter = new NLogLoggerFactoryAdapter(new NameValueCollection()); }