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