public DepthLimiter(int currentDepth, int maximumDepth, PropertyValueConverter propertyValueConverter) { _maximumDestructuringDepth = maximumDepth; _currentDepth = currentDepth; _propertyValueConverter = propertyValueConverter; }
public MessageTemplateProcessor(PropertyValueConverter propertyValueConverter) { _propertyValueConverter = propertyValueConverter; _propertyBinder = new PropertyBinder(_propertyValueConverter); }
public DepthLimiter(int currentDepth, PropertyValueConverter propertyValueConverter) { _currentDepth = currentDepth; _propertyValueConverter = propertyValueConverter; }
public PropertyBinder(PropertyValueConverter valueConverter) { _valueConverter = valueConverter; }
/// <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> 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(_additionalScalarTypes, _additionalDestructuringPolicies); var processor = new MessageTemplateProcessor(converter); return new Logger(processor, _minimumLevel, sink, _enrichers, dispose); }