//primarily meant for testing silent logger static void InvokeConventionMethod( MethodInfo method, Type[] typeArgs, object[] parameters, out LogEventLevel level, out CollectingSink sink) { var logger = GetLogger(method.DeclaringType, out sink); if (method.Name == Write) { level = LogEventLevel.Information; var paramList = new List <object>() { level }; paramList.AddRange(parameters); parameters = paramList.ToArray(); } else { Assert.True(Enum.TryParse(method.Name, out level)); } InvokeMethod(method, logger, parameters, typeArgs); }
public void SpecifyingMinimumLevelOverridesInWriteToLoggerWritesWarningToSelfLog() { var outputs = new List <string>(); using (TemporarySelfLog.SaveTo(outputs)) { var subSink = new CollectingSink(); var subLogger = new LoggerConfiguration() .MinimumLevel.Verbose() .MinimumLevel.Override("Foo.Bar", Debug) .WriteTo.Sink(subSink) .CreateLogger(); var logger = new LoggerConfiguration() .MinimumLevel.Verbose() .MinimumLevel.Override("Foo.Bar", Warning) .WriteTo.Logger(subLogger) .CreateLogger(); var contextLogger = logger.ForContext(Constants.SourceContextPropertyName, "Foo.Bar"); contextLogger.Write(Some.InformationEvent()); } Assert.EndsWith("Minimum level overrides are not supported on sub-loggers " + "and may be removed completely in a future version.", outputs.FirstOrDefault() ?? ""); }
static ILogger GetLogger(Type loggerType, out CollectingSink sink, LogEventLevel level = LogEventLevel.Verbose) { sink = null; if (loggerType == typeof(Logger) || loggerType == typeof(ILogger)) { sink = new CollectingSink(); return(new LoggerConfiguration() .MinimumLevel.Is(level) .WriteTo.Sink(sink) .CreateLogger()); } if (loggerType == typeof(Log)) { sink = new CollectingSink(); Log.CloseAndFlush(); Log.Logger = new LoggerConfiguration() .MinimumLevel.Is(level) .WriteTo.Sink(sink) .CreateLogger(); return(null); } if (loggerType == typeof(SilentLogger)) { return(new SilentLogger()); } throw new ArgumentException($"Logger Type of {loggerType} is not supported"); }
public void WhenTheFilterExpressionIsModifiedTheFilterChanges() { var @switch = new LoggingFilterSwitch(); var sink = new CollectingSink(); var log = new LoggerConfiguration() .Filter.ControlledBy(@switch) .WriteTo.Sink(sink) .CreateLogger(); var v11 = Some.InformationEvent("Adding {Volume} L", 11); log.Write(v11); Assert.Same(v11, sink.SingleEvent); sink.Events.Clear(); @switch.Expression = "Volume > 12"; log.Write(v11); Assert.Equal(0, sink.Events.Count); @switch.Expression = "Volume > 10"; log.Write(v11); Assert.Same(v11, sink.SingleEvent); sink.Events.Clear(); @switch.Expression = null; log.Write(v11); Assert.Same(v11, sink.SingleEvent); }
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local static void EvaluateSingleResult(LogEventLevel level, CollectingSink results) { //evaluate single log event Assert.Equal(1, results.Events.Count); var evt = results.Events.Single(); Assert.Equal(level, evt.Level); }
public void LevelSwitchTakesPrecedenceOverMinimumLevel() { var sink = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.Sink(sink, LogEventLevel.Fatal, new LoggingLevelSwitch()) .CreateLogger(); logger.Write(Some.InformationEvent()); Assert.Single(sink.Events); }
public void WrappingDecoratesTheConfiguredSink() { var sink = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.Dummy(w => w.Sink(sink)) .CreateLogger(); logger.Write(Some.InformationEvent()); Assert.NotEmpty(DummyWrappingSink.Emitted); Assert.NotEmpty(sink.Events); }
public void WrappingSinkRespectsLogEventLevelSetting() { DummyWrappingSink.Emitted.Clear(); var sink = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.DummyWrap(w => w.Sink(sink), LogEventLevel.Error, null) .CreateLogger(); logger.Write(Some.InformationEvent()); Assert.Empty(DummyWrappingSink.Emitted); Assert.Empty(sink.Events); }
public void LastMinimumLevelConfigurationWins() { var sink = new CollectingSink(); var logger = new LoggerConfiguration() .MinimumLevel.ControlledBy(new LoggingLevelSwitch(LogEventLevel.Fatal)) .MinimumLevel.Debug() .WriteTo.Sink(sink) .CreateLogger(); logger.Write(Some.InformationEvent()); Assert.Single(sink.Events); }
public void ExpressionsControlConditionalSinks() { var sink = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.Conditional("A = 1 or A = 2", wt => wt.Sink(sink)) .CreateLogger(); foreach (var a in Enumerable.Range(0, 5)) { logger.Information("{A}", a); } Assert.Equal(2, sink.Events.Count); }
public void ChildLoggerInheritsParentLevelByDefault() { var sink = new CollectingSink(); var logger = new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.Logger(lc => lc .WriteTo.Sink(sink)) .CreateLogger(); logger.Write(Some.DebugEvent()); Assert.Equal(1, sink.Events.Count); }
public void WrappingDecoratesTheConfiguredSink() { DummyWrappingSink.Emitted.Clear(); var sink = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.Dummy(w => w.Sink(sink)) .CreateLogger(); var evt = Some.InformationEvent(); logger.Write(evt); Assert.Same(evt, DummyWrappingSink.Emitted.Single()); Assert.Same(evt, sink.SingleEvent); }
public void ExpressionsControlConditionalEnrichment() { var sink = new CollectingSink(); var logger = new LoggerConfiguration() .Enrich.When("A = 1 or A = 2", e => e.WithProperty("B", 1)) .WriteTo.Sink(sink) .CreateLogger(); foreach (var a in Enumerable.Range(0, 5)) { logger.Information("{A}", a); } Assert.Equal(2, sink.Events.Count(e => e.Properties.ContainsKey("B"))); }
public void WrappingSinkRespectsLevelSwitchSetting() { DummyWrappingSink.Reset(); var sink = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.DummyWrap( w => w.Sink(sink), LogEventLevel.Verbose, new LoggingLevelSwitch(LogEventLevel.Error)) .CreateLogger(); logger.Write(Some.InformationEvent()); Assert.Empty(DummyWrappingSink.Emitted); Assert.Empty(sink.Events); }
static LogEvent[] PipeEvents(string input, InvalidDataHandling invalidDataHandling) { var output = new CollectingSink(); using (var source = new LogEventReader(new StringReader(input))) using (var destination = new LoggerConfiguration() .MinimumLevel.Is(LevelAlias.Minimum) .WriteTo.Sink(output) .CreateLogger()) { EventPipe.PipeEvents(source, destination, invalidDataHandling); } return(output.Events); }
public void ChildLoggerCanOverrideInheritedLevel() { var sink = new CollectingSink(); var logger = new LoggerConfiguration() .MinimumLevel.ControlledBy(new LoggingLevelSwitch(LogEventLevel.Debug)) .WriteTo.Logger(lc => lc .MinimumLevel.Error() .WriteTo.Sink(sink)) .CreateLogger(); logger.Write(Some.DebugEvent()); Assert.Equal(0, sink.Events.Count); }
public void WrappingSinkReceivesEventsWhenLevelIsAppropriate() { DummyWrappingSink.Reset(); var sink = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.DummyWrap( w => w.Sink(sink), LogEventLevel.Error, new LoggingLevelSwitch(LogEventLevel.Verbose)) .CreateLogger(); logger.Write(Some.InformationEvent()); Assert.NotEmpty(DummyWrappingSink.Emitted); Assert.NotEmpty(sink.Events); }
public void ShouldNotEnrichLogEventsWhenMinLevelIsHigherThanProvidedLogLevel(LogEventLevel logMinLevel, LogEventLevel propertLogLevel) { var propValue = Guid.NewGuid(); var propKey = Some.String(); var sink = new CollectingSink(); var logger = new LoggerConfiguration() .MinimumLevel.Is(logMinLevel) .WriteTo.Sink(sink) .CreateLogger(); logger.ForContext(propertLogLevel, propKey, propValue) .Write(logMinLevel, string.Empty); Assert.True(!sink.SingleEvent.Properties.ContainsKey(propKey)); }
public void WrappingDoesNotPermitEnrichment() { var sink = new CollectingSink(); var propertyName = Some.String(); var logger = new LoggerConfiguration() .WriteTo.Dummy(w => w.Sink(sink) .Enrich.WithProperty(propertyName, 1)) .CreateLogger(); var evt = Some.InformationEvent(); logger.Write(evt); Assert.Same(evt, sink.SingleEvent); Assert.False(evt.Properties.ContainsKey(propertyName)); }
public void LowerMinimumLevelOverridesArePropagated() { var sink = new CollectingSink(); var logger = new LoggerConfiguration() .MinimumLevel.Error() .MinimumLevel.Override("Microsoft", LogEventLevel.Debug) .WriteTo.Sink(sink) .CreateLogger(); logger.Write(Some.InformationEvent()); logger.ForContext(Constants.SourceContextPropertyName, "Microsoft.AspNet.Something").Write(Some.InformationEvent()); logger.ForContext <LoggerConfigurationTests>().Write(Some.InformationEvent()); Assert.Single(sink.Events); }
public void ConditionalSinksReceiveEventsMatchingCondition() { var matching = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.Conditional( le => le.Level == LogEventLevel.Warning, w => w.Sink(matching)) .CreateLogger(); logger.Information("Information"); logger.Warning("Warning"); logger.Error("Error"); var evt = Assert.Single(matching.Events); Assert.Equal(LogEventLevel.Warning, evt.Level); }
public void WrappingIsAppliedWhenChaining() { DummyWrappingSink.Emitted.Clear(); var sink1 = new CollectingSink(); var sink2 = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.Dummy(w => w.Sink(sink1) .WriteTo.Sink(sink2)) .CreateLogger(); var evt = Some.InformationEvent(); logger.Write(evt); Assert.Same(evt, DummyWrappingSink.Emitted.Single()); Assert.Same(evt, sink1.SingleEvent); Assert.Same(evt, sink2.SingleEvent); }
static void AssertFiltering(string expression, LogEvent match, params LogEvent[] noMatches) { var sink = new CollectingSink(); var log = new LoggerConfiguration() .Filter.ByIncludingOnly(expression) .WriteTo.Sink(sink) .CreateLogger(); foreach (var noMatch in noMatches) { log.Write(noMatch); } log.Write(match); Assert.Single(sink.Events); Assert.Same(match, sink.Events.Single()); }
public void ModifyingCopiesPassedThroughTheSinkPreservesOriginal() { var secondary = new CollectingSink(); var secondaryLogger = new LoggerConfiguration() .WriteTo.Sink(secondary) .CreateLogger(); var e = Some.InformationEvent(); new LoggerConfiguration() .WriteTo.Logger(secondaryLogger) .CreateLogger() .Write(e); Assert.NotSame(e, secondary.SingleEvent); var p = Some.LogEventProperty(); secondary.SingleEvent.AddPropertyIfAbsent(p); Assert.True(secondary.SingleEvent.Properties.ContainsKey(p.Name)); Assert.False(e.Properties.ContainsKey(p.Name)); }
public void WrappingIsAppliedWhenCallingMultipleTimes() { DummyWrappingSink.Reset(); var sink1 = new CollectingSink(); var sink2 = new CollectingSink(); var logger = new LoggerConfiguration() .WriteTo.Dummy(w => { w.Sink(sink1); w.Sink(sink2); }) .CreateLogger(); var evt = Some.InformationEvent(); logger.Write(evt); Assert.Same(evt, DummyWrappingSink.Emitted.Single()); Assert.Same(evt, sink1.SingleEvent); Assert.Same(evt, sink2.SingleEvent); }