public void OverrideScenarios(string context, bool overrideExpected, LogEventLevel expected)
{
var overrides = new Dictionary<string, LoggingLevelSwitch>
{
["MyApp"] = new LoggingLevelSwitch(LogEventLevel.Debug),
["MyApp.Api.Controllers"] = new LoggingLevelSwitch(LogEventLevel.Information),
["MyApp.Api.Controllers.HomeController"] = new LoggingLevelSwitch(LogEventLevel.Warning),
["MyApp.Api"] = new LoggingLevelSwitch(LogEventLevel.Error)
};
var lom = new LevelOverrideMap(overrides, LogEventLevel.Fatal, null);
LoggingLevelSwitch overriddenSwitch;
LogEventLevel overriddenLevel;
lom.GetEffectiveLevel(context, out overriddenLevel, out overriddenSwitch);
if (overrideExpected)
{
Assert.NotNull(overriddenSwitch);
Assert.Equal(expected, overriddenSwitch.MinimumLevel);
Assert.Equal(LevelAlias.Minimum, overriddenLevel);
}
else
{
Assert.Equal(LogEventLevel.Fatal, overriddenLevel);
Assert.Null(overriddenSwitch);
}
}
internal Logger(
LoggingLevelSwitch levelSwitch,
ILogEventSink sink,
Action dispose = null,
LevelOverrideMap overrideMap = null)
: this(sink, new ExceptionDataEnricher(), dispose, levelSwitch, overrideMap)
{
}
internal Logger(
LoggingLevelSwitch levelSwitch,
ILogEventSink sink,
ILogEventEnricher enricher,
Action dispose = null,
LevelOverrideMap overrideMap = null)
: this(sink, enricher, dispose, levelSwitch, overrideMap)
{
}
// The messageTemplateProcessor, sink and enricher are required. Argument checks are dropped because
// throwing from here breaks the logger's no-throw contract, and callers are all in this file anyway.
Logger(
ILogEventSink sink,
ILogEventEnricher enricher,
Action dispose = null,
LoggingLevelSwitch levelSwitch = null,
LevelOverrideMap overrideMap = null)
{
_sink = sink;
_dispose = dispose;
_levelSwitch = levelSwitch;
_overrideMap = overrideMap;
_enricher = enricher;
}
/// <summary>
/// Create a logger using the configured sinks, enrichers and minimum level.
/// </summary>
/// <returns>The logger.</returns>
/// <remarks>To free resources held by sinks ahead of program shutdown,
/// the returned logger may be cast to <see cref="IDisposable"/> and
/// disposed.</remarks>
public Logger CreateLogger()
{
if (_loggerCreated)
throw new InvalidOperationException("CreateLogger() was previously called and can only be called once.");
_loggerCreated = true;
Action dispose = () =>
{
foreach (var disposable in _logEventSinks.OfType<IDisposable>())
disposable.Dispose();
};
ILogEventSink sink = new SafeAggregateSink(_logEventSinks);
var auditing = _auditSinks.Any();
if (auditing)
sink = new AggregateSink(new[] { sink }.Concat(_auditSinks));
if (_filters.Any())
{
// A throwing filter could drop an auditable event, so exceptions in filters must be propagated
// if auditing is used.
sink = new FilteringSink(sink, _filters, auditing);
}
var converter = new PropertyValueConverter(_maximumDestructuringDepth, _additionalScalarTypes, _additionalDestructuringPolicies, auditing);
var processor = new MessageTemplateProcessor(converter);
ILogEventEnricher enricher;
switch (_enrichers.Count)
{
case 0:
// Should be a rare case, so no problem making that extra interface dispatch.
enricher = new EmptyEnricher();
break;
case 1:
enricher = _enrichers[0];
break;
default:
enricher = new SafeAggregateEnricher(_enrichers);
break;
}
LevelOverrideMap overrideMap = null;
if (_overrides.Count != 0)
{
overrideMap = new LevelOverrideMap(_overrides, _minimumLevel, _levelSwitch);
}
return _levelSwitch == null ?
new Logger(processor, _minimumLevel, sink, enricher, dispose, overrideMap) :
new Logger(processor, _levelSwitch, sink, enricher, dispose, overrideMap);
}
