protected override void OnShown(EventArgs e) { SearchUpdates(); if (_memoryLogger.Logs.Count > 0) { LogRichTextBox.Text = _memoryLogger.Logs.Aggregate(new StringBuilder(), (x, y) => x.AppendLine(y)).ToString(); } LogManager.Configuration.LoggingRules.Remove(_loggingRule); _memoryLogger.Dispose(); _memoryLogger = null; _loggingRule = null; var target = new RichTextBoxTarget { Layout = Program.LogLayout, ControlName = "LogRichTextBox", FormName = Name, AutoScroll = true, CreatedForm = false, Name = "textBox" }; target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Debug", "Gray", "White")); target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Info", "Black", "White")); target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Warn", "DarkRed", "White")); target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Error", "White", "DarkRed", FontStyle.Bold)); target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Fatal", "Yellow", "DarkRed", FontStyle.Bold)); SimpleConfigurator.ConfigureForTargetLogging(target, Program.MinLogLevel); }
public MainForm(TcpServer server, MemoryTarget memoryLogger, LoggingRule loggingRule, Settings settings) { InitializeComponent(); _server = server; _memoryLogger = memoryLogger; _loggingRule = loggingRule; _settings = settings; server.AdministrationsChanged += ServerAdministrationsChanged; server.ClientsChanged += ServerClientsChanged; server.IsRunningChanged += Server_IsRunningChanged; _bindingSource = new BindingSource { DataSource = settings.IpAddresses }; ListenersListBox.DataSource = _bindingSource; PasswordTextBox.Text = settings.Password; Server_IsRunningChanged(this, null); if (server.IsLoading) { ButtonStart.Enabled = false; ButtonStop.Enabled = false; } }
public NLogLogProviderLoggingEnabledTests() { NLogLogManager.ProviderIsAvailableOverride = true; var config = new LoggingConfiguration(); simpleLayoutTarget = new MemoryTarget { Layout = "${level:uppercase=true}|${message}|${exception}" }; ndcLayoutTarget = new MemoryTarget { Layout = "${level:uppercase=true}|${ndc:bottomFrames=10:topFrames=10:separator=;}|${message}|${exception}" }; mdcLayoutTarget = new MemoryTarget { Layout = "${level:uppercase=true}|${mdc:item=Key}|${message}|${exception}" }; config.AddTarget("simpleLayoutMemory", simpleLayoutTarget); config.AddTarget("mdcLayoutTarget", mdcLayoutTarget); config.AddTarget("ndcLayoutMemory", ndcLayoutTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, simpleLayoutTarget)); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, mdcLayoutTarget)); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, ndcLayoutTarget)); LogManager.Configuration = config; nLogLogManager = new NLogLogManager(); sut = nLogLogManager.GetLogger("Test"); }
public void MemoryTarget_LogLevelTest() { ILogger logger = LogManager.GetCurrentClassLogger(); var memoryTarget = new MemoryTarget { Layout = "${level} ${message}" }; SimpleConfigurator.ConfigureForTargetLogging(memoryTarget, LogLevel.Trace); Assert.True(memoryTarget.Logs.Count() == 0); logger.Trace("TTT"); logger.Debug("DDD"); logger.Info("III"); logger.Warn("WWW"); logger.Error("EEE"); logger.Fatal("FFF"); LogManager.Configuration = null; Assert.True(memoryTarget.Logs.Count() == 6); Assert.True(memoryTarget.Logs[0] == "Trace TTT"); Assert.True(memoryTarget.Logs[1] == "Debug DDD"); Assert.True(memoryTarget.Logs[2] == "Info III"); Assert.True(memoryTarget.Logs[3] == "Warn WWW"); Assert.True(memoryTarget.Logs[4] == "Error EEE"); Assert.True(memoryTarget.Logs[5] == "Fatal FFF"); }
public void ThreadLoggerTest() { LogManager.Configuration = new LoggingConfiguration(); ThreadLoggerFactory threadLoggerFactory = ThreadLogManager.GetCurrentClassLoggerFactory(); MemoryTarget target1 = new MemoryTarget("Test123"); LogManager.Configuration.AddRuleForAllLevels(target1, "Thread1.*"); LogManager.ReconfigExistingLoggers(); ThreadLogManager.ThreadName = "Thread1"; threadLoggerFactory.Logger.Debug("Test Thread1"); MemoryTarget target2 = new MemoryTarget("Test123"); Thread thread = new Thread(() => { LogManager.Configuration.AddRuleForAllLevels(target2, "Thread2.*"); LogManager.ReconfigExistingLoggers(); ThreadLogManager.ThreadName = "Thread2"; threadLoggerFactory.Logger.Debug("Test Thread2"); }); thread.Start(); while (thread.ThreadState != ThreadState.Stopped) { Thread.Sleep(10); } Assert.AreEqual(target1.Logs.Count, 1); Assert.AreEqual(target2.Logs.Count, 1); }
internal async Task handleErrorMemory(CancellationToken cancelToken) { MemoryTarget target = LogManager.Configuration.FindTargetByName <MemoryTarget>("errormemory"); while (target.Logs.Count > 0) { string s = target.Logs[0]; if (needToSendThis(s)) { await this.sendMessageWithKeyboard(s, Keyboards.getGotItDeleteButtonKeyboard()); try { await Task.Delay(3000, cancelToken); } catch (OperationCanceledException) { return; } updateLastSentMessage(s); } target.Logs.RemoveAt(0); if (cancelToken.IsCancellationRequested) { return; } } }
/// <summary> /// Layout configuration for <see cref="NLog"/> /// </summary> /// <returns><see cref="LoggingConfiguration"/></returns> public static LoggingConfiguration Configure() { var config = new LoggingConfiguration(); const string callSite = @"${callsite:className=True:skipFrames=1:includeNamespace=False:cleanNamesOfAnonymousDelegates=True:cleanNamesOfAsyncContinuations=True:fileName=False:includeSourcePath=False:methodName=True"; const string trace = @"<${threadid:padding=2}> |${level:format=FirstCharacter}| ${date:format=HH\:mm\:ss.ff} " + callSite + @":when:when='${event-properties:dtype}' != '' and level<=LogLevel.Info}" + @"${literal:text=(:when:when='${event-properties:dtype}' != ''}" + @"${event-properties:msg}" + @"${literal:text=):when:when='${event-properties:dtype}' != ''} " + @"${literal:text=[:when:when='${event-properties:dtype}' != ''}" + @"${event-properties:dtype}" + @"${literal:text=]:when:when='${event-properties:dtype}' != ''} " + @"${message:when='${event-properties:msg}' == ''}" + @"${exception}"; var consoleTarget = new ColoredConsoleTarget { Name = "Console", Layout = trace, }; _memory = new MemoryTarget { Name = "Memory", Layout = trace, }; config.AddTarget(consoleTarget); config.AddTarget(_memory); LogManager.Configuration = config; return(config); }
public void NLogWithTransaction() { var assembly = typeof(ApmTraceIdLayoutRenderer).Assembly; global::NLog.Config.ConfigurationItemFactory.Default.RegisterItemsFromAssembly(assembly); Agent.Setup(new AgentComponents(payloadSender: new NoopPayloadSender())); var target = new MemoryTarget(); target.Layout = "${ElasticApmTraceId}|${ElasticApmTransactionId}|${message}"; global::NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug); var logger = LogManager.GetLogger("Example"); logger.Debug("PreTransaction"); string traceId = null; string transactionId = null; Agent.Tracer.CaptureTransaction("TestTransaction", "Test", t => { traceId = t.TraceId; transactionId = t.Id; logger.Debug("InTransaction"); }); logger.Debug("PostTransaction"); target.Logs.Count.Should().Be(3); target.Logs[0].Should().Be("||PreTransaction"); target.Logs[1].Should().Be($"{traceId}|{transactionId}|InTransaction"); target.Logs[2].Should().Be("||PostTransaction"); }
public void ExceptionTest() { var target = new MemoryTarget { Layout = @"${exception:format=tostring}" }; SimpleConfigurator.ConfigureForTargetLogging(target); var logger = LogManager.GetCurrentClassLogger(); try { throw new InvalidOperationException(); } catch (Exception ex) { Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US", false); Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US", false); logger.Error(ex, ""); #if !NETSTANDARD Thread.CurrentThread.CurrentUICulture = new CultureInfo("de-DE", false); Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE", false); #endif logger.Error(ex, ""); Assert.Equal(2, target.Logs.Count); Assert.NotNull(target.Logs[0]); Assert.NotNull(target.Logs[1]); Assert.Equal(target.Logs[0], target.Logs[1]); } }
public void Should_preserve_correct_callsite_information() { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var target = new MemoryTarget(); config.AddTarget("target", target); // Step 3. Set target properties target.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${callsite} ${message}"; // Step 4. Define rules var rule = new LoggingRule("*", LogLevel.Debug, target); config.LoggingRules.Add(rule); var factory = new NLogFactory(config); WriteLogMessage(factory); var logMessage = target.Logs[0]; Assert.Contains("CallSiteTests.WriteLogMessage", logMessage); }
public string GetLogs() { MemoryTarget memoryTarget = (MemoryTarget)LogManager.Configuration.FindTargetByName(MEMORY_TARGET_NAME); return(string.Join(Environment.NewLine, memoryTarget.Logs)); }
public void MachineNameInPropertyIsRendered() { var layout = new JsonWithPropertiesLayout(); layout.Properties.Add(new StructuredLoggingProperty("machinename", "${machinename}")); var target = new MemoryTarget { Name = Guid.NewGuid().ToString(), Layout = layout }; SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Trace); TimeSource.Current = new FakeTimeSource(); var logger = LogManager.GetCurrentClassLogger(); var logEvent = new LogEventInfo(LogLevel.Trace, LoggerName, TestMessage); logger.Log(logEvent); Assert.That(target.Logs.Count, Is.EqualTo(1)); var output = target.Logs[0]; Assert.That(output, Does.Contain("\"machinename\":\"")); Assert.That(output, Does.Not.Contain("${machinename}")); }
public void VarInPropertyIsRendered() { var layout = new JsonWithPropertiesLayout(); layout.Properties.Add(new StructuredLoggingProperty("key1", "${var:foo}")); var target = new MemoryTarget { Name = Guid.NewGuid().ToString(), Layout = layout }; var fooValue = Guid.NewGuid().ToString(); SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Trace); LogManager.Configuration.Variables.Add("foo", fooValue); TimeSource.Current = new FakeTimeSource(); var logger = LogManager.GetCurrentClassLogger(); var logEvent = new LogEventInfo(LogLevel.Trace, LoggerName, TestMessage); logger.Log(logEvent); Assert.That(target.Logs.Count, Is.EqualTo(1)); var output = target.Logs[0]; Assert.That(output, Does.Contain(fooValue)); Assert.That(output, Does.Contain($"\"key1\":\"{fooValue}\"")); Assert.That(output, Does.Not.Contain("var:")); Assert.That(output, Does.Not.Contain("${:")); Assert.That(output, Does.Not.Contain("foo")); }
void MvcApplication_BeginRequest(object sender, EventArgs e) { try { if (HttpContext.Current.Request.QueryString["vm"] != null && Convert.ToInt32(HttpContext.Current.Request.QueryString["vm"]) == 10) { MemoryTarget _logTarget = null; _loggerName = Guid.NewGuid().ToString().Replace("-", string.Empty); HttpContext.Current.Items.Add("LoggerName", _loggerName); _logTarget = new MemoryTarget(); _logTarget.Name = _loggerName.ToString(); LoggingRule rule = new LoggingRule(_loggerName, _logTarget); rule.EnableLoggingForLevel(LogLevel.Debug); rule.EnableLoggingForLevel(LogLevel.Trace); rule.EnableLoggingForLevel(LogLevel.Info); rule.EnableLoggingForLevel(LogLevel.Warn); rule.EnableLoggingForLevel(LogLevel.Error); rule.EnableLoggingForLevel(LogLevel.Fatal); LogManager.Configuration.LoggingRules.Add(rule); LogManager.Configuration.Reload(); } } catch (Exception ex) { LogEventInfo info = new LogEventInfo(LogLevel.Error, ECMSSettings.DEFAULT_LOGGER, ex.ToString()); ECMSLogger.Instance.Log(info); } }
void MvcApplication_EndRequest(object sender, EventArgs e) { try { var loggerName = Convert.ToString(HttpContext.Current.Items["LoggerName"]); if (!string.IsNullOrEmpty(loggerName)) { var rule = LogManager.Configuration.LoggingRules.Where(x => x.NameMatches(loggerName)).FirstOrDefault(); if (rule != null && rule.Targets.Count > 0) { MemoryTarget target = rule.Targets.Where(x => x.Name == _loggerName).FirstOrDefault() as MemoryTarget; if (target != null) { target.Dispose(); LogManager.Configuration.LoggingRules.Remove(rule); LogManager.Configuration.RemoveTarget(target.Name); LogManager.Configuration.Reload(); } } } } catch (Exception ex) { LogEventInfo info = new LogEventInfo(LogLevel.Error, ECMSSettings.DEFAULT_LOGGER, ex.ToString()); ECMSLogger.Instance.Log(info); } }
public void MemoryTarget_EmptyMessageTest() { ILogger logger = LogManager.GetCurrentClassLogger(); var memoryTarget = new MemoryTarget { Layout = "${level} ${message}" }; SimpleConfigurator.ConfigureForTargetLogging(memoryTarget, LogLevel.Trace); logger.Trace("TTT"); logger.Debug(String.Empty); logger.Info("III"); logger.Warn(""); logger.Error("EEE"); LogManager.Configuration = null; Assert.True(memoryTarget.Logs.Count() == 5); Assert.True(memoryTarget.Logs[0] == "Trace TTT"); Assert.True(memoryTarget.Logs[1] == "Debug "); Assert.True(memoryTarget.Logs[2] == "Info III"); Assert.True(memoryTarget.Logs[3] == "Warn "); Assert.True(memoryTarget.Logs[4] == "Error EEE"); }
private static void AssertSingleMessage(MemoryTarget memoryTarget, string expectedMessage) { Assert.Equal(1, memoryTarget.Logs.Count); var log = memoryTarget.Logs.Single(); Assert.Equal(expectedMessage, log); }
protected static void TestLogger(Action <ILogger, Func <List <string> > > act) { // These layout renderers need to registered statically as ultimately ConfigurationItemFactory.Default is called in the call stack. LayoutRenderer.Register <ApmTraceIdLayoutRenderer>(ApmTraceIdLayoutRenderer.Name); //generic LayoutRenderer.Register <ApmTransactionIdLayoutRenderer>(ApmTransactionIdLayoutRenderer.Name); //generic var logFactory = new LogFactory(); var logConfig = new Config.LoggingConfiguration(logFactory); var ecsLayout = new EcsLayout(); ecsLayout.ExcludeProperties.Add("NotX"); var memoryTarget = new MemoryTarget { Layout = ecsLayout, OptimizeBufferReuse = true }; logConfig.AddRule(LogLevel.Trace, LogLevel.Fatal, memoryTarget); logConfig.DefaultCultureInfo = System.Globalization.CultureInfo.InvariantCulture; logFactory.Configuration = logConfig; List <string> GetLogEvents() => memoryTarget.Logs.ToList(); var logger = logFactory.GetCurrentClassLogger(); act(logger, GetLogEvents); }
private async Task <IList <string> > RunCommand(string cmd, Dictionary <string, string> placeHolders = null) { var config = new LoggingConfiguration(); var memoryTarget = new MemoryTarget() { Layout = @"${message}${onexception:${exception:format=tostring}}" }; config.AddTarget("logger", memoryTarget); var consoleRule = new LoggingRule("*", LogLevel.Debug, memoryTarget); config.LoggingRules.Add(consoleRule); var args = cmd.Split(' ') .Select(s => placeHolders?.ContainsKey(s) == true ? placeHolders[s] : s) .ToArray(); using (var factory = new LogFactory(config)) { var logger = factory.GetLogger("logger"); var succeed = await new Program(logger).Process(args); Assert.True(succeed, string.Join(Environment.NewLine, memoryTarget.Logs)); } return(memoryTarget.Logs); }
public void UsingLoggingAspectWithNLogShouldUseNlogger() { // arrange - setup nlog LoggingConfiguration config = new LoggingConfiguration(); MemoryTarget memoryTarget = new MemoryTarget { Layout = @"${message}" }; config.AddTarget("memory", memoryTarget); LoggingRule rule = new LoggingRule("*", LogLevel.Debug, memoryTarget); config.LoggingRules.Add(rule); LogManager.Configuration = config; Mock <IConfigurationProvider> mock = new Mock <IConfigurationProvider>(); mock.Setup(provider => provider.ShouldLog(It.IsAny <LogAttribute>())).Returns(true); LogAttribute.ConfigurationProvider = mock.Object; // arrange - setup logger LogAttribute.Logger = new NLogLogger("memory"); // act Person person = new Person { Name = "test", Balance = 0.0d }; person.Should().NotBeNull(); // assert memoryTarget.Logs.Count.Should().Be(9, "because we called the logging 9 times"); }
public LogsModuleViewModel(ApplicationNavigationPartViewModel application_navigation_part, ToolsNavigationPartViewModel tools_navigation_part) { ApplicationNavigationPart = application_navigation_part; ToolsNavigationPart = tools_navigation_part; log_target = LogManager.Configuration.AllTargets.OfType <MemoryTarget>().FirstOrDefault(); }
public LogTests() { _configuration = new LoggingConfiguration(); _memoryTarget = new MemoryTarget { Name = "mem", Layout = "${message}" }; _configuration.AddTarget(_memoryTarget); }
public static void SetupLogging(string username) { Username = username; var config = LogManager.Configuration; if (config == null) { config = new LoggingConfiguration(); } var loggername = "asyncslack"; if (config.FindTargetByName(loggername) != null) { config.RemoveTarget(loggername); } var slackTarget = new SlackTarget { Layout = "${message} ${exception:format=tostring}", WebHookUrl = "https://hooks.slack.com/services/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", Channel = "#sovnd-client-logs", Username = username, Compact = true }; AsyncTargetWrapper asyncSlack = new AsyncTargetWrapper(slackTarget); config.AddTarget(loggername, asyncSlack); var slackTargetRules = new LoggingRule("*", LogLevel.Error, asyncSlack); config.LoggingRules.Add(slackTargetRules); loggername = "asyncmem"; if (memoryTarget == null) { memoryTarget = new MemoryTarget { Layout = "${message} ${exception:format=tostring}" }; config.AddTarget(loggername, memoryTarget); var memTargetRules = new LoggingRule("*", LogLevel.Trace, memoryTarget); config.LoggingRules.Add(memTargetRules); if (config.FindTargetByName(loggername) != null) { config.RemoveTarget(loggername); } } LogManager.Configuration = config; BugSenseHandler.Instance.UserIdentifier = username; var ver = Assembly.GetExecutingAssembly().GetName().Version.ToString(); LogTo.Error("SOVND Ver {0} running as {1}", ver, username); }
static ProfilerEvent RunProfiler(Action <Profiler> thunk) { var target = new MemoryTarget(null); var pro = Profiler.ForLogger(Logger.Create(target)); thunk(pro); return((ProfilerEvent)target.Events[0]); }
/// <summary> /// Get a target to allow assertions to be made against the Nlog /// </summary> public static MemoryTarget GetMemoryTarget(this Logger log, string layout, LogLevel logLevel) { MemoryTarget memoryTarget = new MemoryTarget { Layout = layout }; SimpleConfigurator.ConfigureForTargetLogging(memoryTarget, logLevel); return(memoryTarget); }
public void Setup() { _target = new MemoryTarget { Layout = "${message}" }; SimpleConfigurator.ConfigureForTargetLogging(_target, LogLevel.Trace); LogWriter.SetFactory(new NLogWriterFactory()); _target.Logs.Clear(); }
public void SetUp() { log = new MemoryTarget(); SimpleConfigurator.ConfigureForTargetLogging(log); log.Layout = "${longdate} ${uppercase:${level}} ${message} ${exception:format=tostring}"; // Uncomment the next line if tests fails due to UnauthorizedAccessException // Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); File.Delete("text.txt.out"); }
public void Should_preserve_correct_callsite_information() { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var target = new MemoryTarget(); var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper(target) { TimeToSleepBetweenBatches = 0 }; config.AddTarget("target", wrapper); // Step 3. Set target properties target.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; // Step 4. Define rules var rule = new LoggingRule("*", LogLevel.Debug, wrapper); config.LoggingRules.Add(rule); LogManager.Configuration = config; var factory = new NLogFactory(config); var logger = factory.Create("MyLoggerName"); WriteLogMessage(logger); LogManager.Flush(); var logMessage = target.Logs[0]; Assert.Contains("MyLoggerName", logMessage); // See that LogManager.ReconfigExistingLoggers() is able to upgrade the Logger target.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${callsite} ${message}"; LogManager.ReconfigExistingLoggers(); WriteLogMessage(logger); LogManager.Flush(); logMessage = target.Logs[1]; Assert.Contains("CallSiteTests.WriteLogMessage", logMessage); // See that LogManager.ReconfigExistingLoggers() is able to upgrade the Logger target.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${callsite} ${message} ThreadId=${threadid}"; LogManager.ReconfigExistingLoggers(); WriteLogMessage(logger); LogManager.Flush(); logMessage = target.Logs[2]; Assert.Contains("ThreadId=" + Thread.CurrentThread.ManagedThreadId.ToString(), logMessage); // See that interface logging also works (Improve support for Microsoft.Extension.Logging.ILogger replacement) INLogLogger ilogger = logger; WriteLogMessage(ilogger); LogManager.Flush(); logMessage = target.Logs[3]; Assert.Contains("CallSiteTests.WriteLogMessage", logMessage); }
private static LoggingConfiguration CreateConfigWithMemoryTarget(out MemoryTarget memoryTarget, string levelMessage = "${level}|${message}") { var config = new LoggingConfiguration(); memoryTarget = new MemoryTarget { Layout = levelMessage }; config.AddRuleForAllLevels(memoryTarget); return(config); }
public void SetupTests() { ConfigurationItemFactory.Default.Layouts.RegisterDefinition("flattenedjsonlayout", typeof(FlattenedJsonLayout)); _parameter1 = "With Extra String!!"; _parameter2 = null; _target = new MemoryTarget(); _target.Layout = new FlattenedJsonLayout(); }
public void SetUp() { var cfg = new LoggingConfiguration(); _logTarget = new MemoryTarget("mem") { Layout = new SimpleLayout("${Logger}|${Level}|${Message}|${exception}|${all-event-properties}") }; cfg.AddTarget(_logTarget); cfg.AddRule(global::NLog.LogLevel.Trace, global::NLog.LogLevel.Error, _logTarget); LogManager.Configuration = cfg; }