/// <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 ILogger CreateLogger() { if (!_logEventSinks.Any()) { return(new SilentLogger()); } Action dispose = () => { foreach (var disposable in _logEventSinks.OfType <IDisposable>()) { disposable.Dispose(); } }; var sink = new SafeAggregateSink(_logEventSinks); if (_filters.Any()) { sink = new SafeAggregateSink(new[] { new FilteringSink(sink, _filters) }); } var converter = new PropertyValueConverter(_maximumDestructuringDepth, _additionalScalarTypes, _additionalDestructuringPolicies); var processor = new MessageTemplateProcessor(converter); return(_levelSwitch == null ? new Logger(processor, _minimumLevel, sink, _enrichers, dispose) : new Logger(processor, _levelSwitch, sink, _enrichers, dispose)); }
/// <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); if (_filters.Any()) { sink = new FilteringSink(sink, _filters); } var converter = new PropertyValueConverter(_maximumDestructuringDepth, _additionalScalarTypes, _additionalDestructuringPolicies); 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)); }
public void AnExceptionThrownByASinkIsNotPropagated() { var thrown = false; var s = new SafeAggregateSink(new[] { new DelegatingSink(le => { thrown = true; throw new Exception("No go, pal."); }) }); s.Emit(Some.InformationEvent()); Assert.True(thrown); }
public void AnExceptionThrownByASinkIsNotPropagated() { var thrown = false; var s = new SafeAggregateSink(new[] { new DelegatingSink(le => { thrown = true; throw new Exception("No go, pal."); }) }); s.Emit(Some.InformationEvent()); Assert.IsTrue(thrown); }
public void WhenASinkThrowsOtherSinksAreStillInvoked() { bool called1 = false, called2 = false; var s = new SafeAggregateSink(new[] { new DelegatingSink(le => called1 = true), new DelegatingSink(le => { throw new Exception("No go, pal."); }), new DelegatingSink(le => called2 = true) }); s.Emit(Some.InformationEvent()); Assert.True(called1 && called2); }
public void WhenASinkThrowsOtherSinksAreStillInvoked() { bool called1 = false, called2 = false; var s = new SafeAggregateSink(new[] { new DelegatingSink(le => called1 = true), new DelegatingSink(le => { throw new Exception("No go, pal."); }), new DelegatingSink(le => called2 = true) }); s.Emit(Some.InformationEvent()); Assert.IsTrue(called1 && called2); }
/// <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 ILogger CreateLogger() { Action dispose = () => { foreach (var disp in _logEventSinks.OfType <IDisposable>()) { disp.Dispose(); } }; var sink = new SafeAggregateSink(_logEventSinks); if (_filters.Any()) { sink = new SafeAggregateSink(new[] { new FilteringSink(sink, _filters) }); } var converter = CreatePropertyValueConverter(); var processor = new MessageTemplateProcessor(converter); return(new Logger(processor, _minimumLevel, sink, _enrichers, dispose)); }
/// <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 ILogger CreateLogger() { Action dispose = () => { foreach (var disp in _logEventSinks.OfType<IDisposable>()) disp.Dispose(); }; var sink = new SafeAggregateSink(_logEventSinks); if (_filters.Any()) sink = new SafeAggregateSink(new[] { new FilteringSink(sink, _filters) }); var converter = CreatePropertyValueConverter(); var processor = new MessageTemplateProcessor(converter); return new Logger(processor, _minimumLevel, sink, _enrichers, dispose); }
/// <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); }
/// <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> /// <exception cref="InvalidOperationException">When the logger is already created</exception> public Logger CreateLogger() { if (_loggerCreated) { throw new InvalidOperationException("CreateLogger() was previously called and can only be called once."); } _loggerCreated = true; 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, _maximumStringLength, _maximumCollectionCount, _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: // Enrichment failures are not considered blocking for auditing purposes. enricher = new SafeAggregateEnricher(_enrichers); break; } LevelOverrideMap overrideMap = null; if (_overrides.Count != 0) { overrideMap = new LevelOverrideMap(_overrides, _minimumLevel, _levelSwitch); } var disposableSinks = _logEventSinks.Concat(_auditSinks).OfType <IDisposable>().ToArray(); void Dispose() { foreach (var disposable in disposableSinks) { disposable.Dispose(); } } return(_levelSwitch == null ? new Logger(processor, _minimumLevel, sink, enricher, Dispose, overrideMap) : new Logger(processor, _levelSwitch, sink, enricher, Dispose, overrideMap)); }
/// <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 ILogger CreateLogger() { Action dispose = () => { foreach (var disposable in _logEventSinks.OfType<IDisposable>()) disposable.Dispose(); }; var sink = new SafeAggregateSink(_logEventSinks); if (_filters.Any()) sink = new SafeAggregateSink(new[] { new FilteringSink(sink, _filters) }); var converter = new PropertyValueConverter(_maximumDestructuringDepth, _additionalScalarTypes, _additionalDestructuringPolicies); var processor = new MessageTemplateProcessor(converter); return _levelSwitch == null ? new Logger(processor, _minimumLevel, sink, _enrichers, dispose) : new Logger(processor, _levelSwitch, sink, _enrichers, dispose); }