//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);
}
