From bc1925d481677095b53742eff50e5da3cd732526 Mon Sep 17 00:00:00 2001 From: Sergey Rogovtsev Date: Wed, 24 Jun 2020 17:31:12 +0300 Subject: [PATCH 1/5] nblumhardt/autofac-serilog-integration#34: adding tests for current behavior --- .../ActivatorTests.cs | 80 +++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 test/AutofacSerilogIntegration.Tests/ActivatorTests.cs diff --git a/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs b/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs new file mode 100644 index 0000000..0643d0b --- /dev/null +++ b/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs @@ -0,0 +1,80 @@ +using System; +using Autofac; +using Moq; +using Serilog; +using Xunit; + +namespace AutofacSerilogIntegration.Tests +{ + public class ActivatorTests + { + private readonly Mock _logger; + + public ActivatorTests() + { + _logger = new Mock(); + _logger.SetReturnsDefault(_logger.Object); + } + + private void ResolveInstance(Action configureContainer) + { + var containerBuilder = new ContainerBuilder(); + containerBuilder.RegisterType>(); + containerBuilder.RegisterLogger(_logger.Object); + configureContainer(containerBuilder); + using (var container = containerBuilder.Build()) + { + container.Resolve>(); + } + } + + private void VerifyLoggerCreation(Func times) + => _logger.Verify(logger => logger.ForContext(typeof(TContext)), times); + + [Fact] + public void Default_ReflectionActivator_DependencyWithLogger_ShouldCreateLogger() + { + ResolveInstance(containerBuilder => containerBuilder.RegisterType()); + VerifyLoggerCreation(Times.AtLeastOnce); + } + + [Fact] + public void Default_ReflectionActivator_DependencyWithoutLogger_ShouldNotCreateLogger() + { + ResolveInstance(containerBuilder => containerBuilder.RegisterType()); + VerifyLoggerCreation(Times.Never); + } + + [Fact] + //legacy behavior + public void Default_ProvidedInstanceActivator_DependencyWithoutLogger_CreatesLogger() + { + ResolveInstance(containerBuilder => containerBuilder.RegisterInstance(new DependencyWithoutLogger())); + VerifyLoggerCreation(Times.AtLeastOnce); + } + + [Fact] + //legacy behavior + public void Default_DelegateActivator_DependencyWithoutLogger_CreatesLogger() + { + ResolveInstance(containerBuilder => containerBuilder.Register(_ => new DependencyWithoutLogger())); + VerifyLoggerCreation(Times.AtLeastOnce); + } + + private class Component + { + public Component(TDependency dependency) + { + } + } + + private class DependencyWithLogger + { + public DependencyWithLogger(ILogger logger) + { + } + } + + private class DependencyWithoutLogger {} + } +} From db03a39d4ae7e7b7dcc7dfcc626b9723fbbf5a9b Mon Sep 17 00:00:00 2001 From: Sergey Rogovtsev Date: Wed, 24 Jun 2020 17:47:46 +0300 Subject: [PATCH 2/5] nblumhardt/autofac-serilog-integration#34: simple legacy-preserving switch to limit logger activations --- .../ContextualLoggingModule.cs | 12 +++- .../SerilogContainerBuilderExtensions.cs | 10 +++- .../ActivatorTests.cs | 57 ++++++++++++++----- 3 files changed, 59 insertions(+), 20 deletions(-) diff --git a/src/AutofacSerilogIntegration/ContextualLoggingModule.cs b/src/AutofacSerilogIntegration/ContextualLoggingModule.cs index 4790117..ed0ca9a 100644 --- a/src/AutofacSerilogIntegration/ContextualLoggingModule.cs +++ b/src/AutofacSerilogIntegration/ContextualLoggingModule.cs @@ -18,6 +18,7 @@ internal class ContextualLoggingModule : Module readonly bool _autowireProperties; readonly bool _skipRegistration; readonly bool _dispose; + readonly bool _onlyKnownConsumers; [Obsolete("Do not use this constructor. This is required by the Autofac assembly scanning")] public ContextualLoggingModule() @@ -26,11 +27,12 @@ public ContextualLoggingModule() _skipRegistration = true; } - internal ContextualLoggingModule(ILogger logger = null, bool autowireProperties = false, bool dispose = false) + internal ContextualLoggingModule(ILogger logger = null, bool autowireProperties = false, bool dispose = false, bool onlyKnownConsumers = false) { _logger = logger; _autowireProperties = autowireProperties; _dispose = dispose; + _onlyKnownConsumers = onlyKnownConsumers; _skipRegistration = false; } @@ -94,8 +96,7 @@ protected override void AttachToComponentRegistration(IComponentRegistryBuilder PropertyInfo[] targetProperties = null; - var ra = registration.Activator as ReflectionActivator; - if (ra != null) + if (registration.Activator is ReflectionActivator ra) { // As of Autofac v4.7.0 "FindConstructors" will throw "NoConstructorsFoundException" instead of returning an empty array // See: https://github.com/autofac/Autofac/pull/895 & https://github.com/autofac/Autofac/issues/733 @@ -130,6 +131,11 @@ protected override void AttachToComponentRegistration(IComponentRegistryBuilder if (!usesLogger) return; } + else + { + if (_onlyKnownConsumers) + return; + } registration.Preparing += (sender, args) => { diff --git a/src/AutofacSerilogIntegration/SerilogContainerBuilderExtensions.cs b/src/AutofacSerilogIntegration/SerilogContainerBuilderExtensions.cs index 0d1711e..cf4a911 100644 --- a/src/AutofacSerilogIntegration/SerilogContainerBuilderExtensions.cs +++ b/src/AutofacSerilogIntegration/SerilogContainerBuilderExtensions.cs @@ -19,11 +19,15 @@ public static class SerilogContainerBuilderExtensions /// If true, properties on reflection-based components of type will /// be injected. /// + /// + /// If true, only the registrations that can be verified to use will be modified to access the logger, + /// thus avoiding unnecessary logger calls. + /// /// An object supporting method chaining. - public static IModuleRegistrar RegisterLogger(this ContainerBuilder builder, ILogger logger = null, bool autowireProperties = false, bool dispose = false) + public static IModuleRegistrar RegisterLogger(this ContainerBuilder builder, ILogger logger = null, bool autowireProperties = false, bool dispose = false, bool onlyKnownConsumers = false) { - if (builder == null) throw new ArgumentNullException("builder"); - return builder.RegisterModule(new ContextualLoggingModule(logger, autowireProperties, dispose)); + if (builder == null) throw new ArgumentNullException(nameof(builder)); + return builder.RegisterModule(new ContextualLoggingModule(logger, autowireProperties, dispose, onlyKnownConsumers)); } } } diff --git a/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs b/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs index 0643d0b..271053a 100644 --- a/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs +++ b/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs @@ -16,11 +16,16 @@ public ActivatorTests() _logger.SetReturnsDefault(_logger.Object); } - private void ResolveInstance(Action configureContainer) + private void ResolveInstance(Action configureContainer, bool? onlyKnownConsumers) { var containerBuilder = new ContainerBuilder(); + + if (onlyKnownConsumers == null) + containerBuilder.RegisterLogger(_logger.Object); + else + containerBuilder.RegisterLogger(_logger.Object, onlyKnownConsumers: onlyKnownConsumers.Value); + containerBuilder.RegisterType>(); - containerBuilder.RegisterLogger(_logger.Object); configureContainer(containerBuilder); using (var container = containerBuilder.Build()) { @@ -31,36 +36,60 @@ private void ResolveInstance(Action configureCont private void VerifyLoggerCreation(Func times) => _logger.Verify(logger => logger.ForContext(typeof(TContext)), times); - [Fact] - public void Default_ReflectionActivator_DependencyWithLogger_ShouldCreateLogger() + [Theory] + [InlineData(null)] + [InlineData(false)] + [InlineData(true)] + public void ReflectionActivator_DependencyWithLogger_ShouldCreateLogger(bool? onlyKnownConsumers) { - ResolveInstance(containerBuilder => containerBuilder.RegisterType()); + ResolveInstance(containerBuilder => containerBuilder.RegisterType(), onlyKnownConsumers); VerifyLoggerCreation(Times.AtLeastOnce); } - [Fact] - public void Default_ReflectionActivator_DependencyWithoutLogger_ShouldNotCreateLogger() + [Theory] + [InlineData(null)] + [InlineData(false)] + [InlineData(true)] + public void ReflectionActivator_DependencyWithoutLogger_ShouldNotCreateLogger(bool? onlyKnownConsumers) { - ResolveInstance(containerBuilder => containerBuilder.RegisterType()); + ResolveInstance(containerBuilder => containerBuilder.RegisterType(), onlyKnownConsumers); VerifyLoggerCreation(Times.Never); } - [Fact] + [Theory] + [InlineData(null)] + [InlineData(false)] //legacy behavior - public void Default_ProvidedInstanceActivator_DependencyWithoutLogger_CreatesLogger() + public void Default_ProvidedInstanceActivator_DependencyWithoutLogger_CreatesLogger(bool? onlyKnownConsumers) { - ResolveInstance(containerBuilder => containerBuilder.RegisterInstance(new DependencyWithoutLogger())); + ResolveInstance(containerBuilder => containerBuilder.RegisterInstance(new DependencyWithoutLogger()), onlyKnownConsumers); VerifyLoggerCreation(Times.AtLeastOnce); } - [Fact] + [Theory] + [InlineData(null)] + [InlineData(false)] //legacy behavior - public void Default_DelegateActivator_DependencyWithoutLogger_CreatesLogger() + public void Default_DelegateActivator_DependencyWithoutLogger_CreatesLogger(bool? onlyKnownConsumers) { - ResolveInstance(containerBuilder => containerBuilder.Register(_ => new DependencyWithoutLogger())); + ResolveInstance(containerBuilder => containerBuilder.Register(_ => new DependencyWithoutLogger()), onlyKnownConsumers); VerifyLoggerCreation(Times.AtLeastOnce); } + [Fact] + public void OnlyKnownCustomers_ProvidedInstanceActivator_DependencyWithoutLogger_ShouldNotCreateLogger() + { + ResolveInstance(containerBuilder => containerBuilder.RegisterInstance(new DependencyWithoutLogger()), onlyKnownConsumers: true); + VerifyLoggerCreation(Times.Never); + } + + [Fact] + public void OnlyKnownCustomers_DelegateActivator_DependencyWithoutLogger_ShouldNotCreateLogger() + { + ResolveInstance(containerBuilder => containerBuilder.Register(_ => new DependencyWithoutLogger()), onlyKnownConsumers: true); + VerifyLoggerCreation(Times.Never); + } + private class Component { public Component(TDependency dependency) From c8cbb2465fef6dccfee8ef4a0ff3a3be764cf134 Mon Sep 17 00:00:00 2001 From: Sergey Rogovtsev Date: Sat, 4 Jul 2020 11:36:47 +0300 Subject: [PATCH 3/5] nblumhardt/autofac-serilog-integration#34: do not providing ILogger to DelegateActivator unless explicitly asked to * decided against providing to ProvidedInstanceActivator --- .../ContextualLoggingModule.cs | 78 ++++++++++--------- .../SerilogContainerBuilderExtensions.cs | 12 +-- .../ActivatorTests.cs | 66 ++++++++++------ 3 files changed, 92 insertions(+), 64 deletions(-) diff --git a/src/AutofacSerilogIntegration/ContextualLoggingModule.cs b/src/AutofacSerilogIntegration/ContextualLoggingModule.cs index ed0ca9a..6f92f2e 100644 --- a/src/AutofacSerilogIntegration/ContextualLoggingModule.cs +++ b/src/AutofacSerilogIntegration/ContextualLoggingModule.cs @@ -3,6 +3,7 @@ using System.Reflection; using Autofac; using Autofac.Core; +using Autofac.Core.Activators.ProvidedInstance; using Autofac.Core.Activators.Reflection; using Autofac.Core.Registration; using Serilog; @@ -18,7 +19,7 @@ internal class ContextualLoggingModule : Module readonly bool _autowireProperties; readonly bool _skipRegistration; readonly bool _dispose; - readonly bool _onlyKnownConsumers; + readonly bool _alwaysSupplyParameter; [Obsolete("Do not use this constructor. This is required by the Autofac assembly scanning")] public ContextualLoggingModule() @@ -27,12 +28,12 @@ public ContextualLoggingModule() _skipRegistration = true; } - internal ContextualLoggingModule(ILogger logger = null, bool autowireProperties = false, bool dispose = false, bool onlyKnownConsumers = false) + internal ContextualLoggingModule(ILogger logger = null, bool autowireProperties = false, bool dispose = false, bool alwaysSupplyParameter = false) { _logger = logger; _autowireProperties = autowireProperties; _dispose = dispose; - _onlyKnownConsumers = onlyKnownConsumers; + _alwaysSupplyParameter = alwaysSupplyParameter; _skipRegistration = false; } @@ -96,45 +97,52 @@ protected override void AttachToComponentRegistration(IComponentRegistryBuilder PropertyInfo[] targetProperties = null; - if (registration.Activator is ReflectionActivator ra) + switch (registration.Activator) { - // As of Autofac v4.7.0 "FindConstructors" will throw "NoConstructorsFoundException" instead of returning an empty array - // See: https://github.com/autofac/Autofac/pull/895 & https://github.com/autofac/Autofac/issues/733 - ConstructorInfo[] ctors; - try - { - ctors = ra.ConstructorFinder.FindConstructors(ra.LimitType); - } - catch (Exception ex) when (ex.GetType().Name == "NoConstructorsFoundException") // Avoid needing to upgrade our Autofac reference to 4.7.0 - { - ctors = new ConstructorInfo[0]; - } - - var usesLogger = - ctors.SelectMany(ctor => ctor.GetParameters()).Any(pi => pi.ParameterType == typeof (ILogger)); + case ReflectionActivator ra: + // As of Autofac v4.7.0 "FindConstructors" will throw "NoConstructorsFoundException" instead of returning an empty array + // See: https://github.com/autofac/Autofac/pull/895 & https://github.com/autofac/Autofac/issues/733 + ConstructorInfo[] ctors; + try + { + ctors = ra.ConstructorFinder.FindConstructors(ra.LimitType); + } + catch (Exception ex) when (ex.GetType().Name == "NoConstructorsFoundException") // Avoid needing to upgrade our Autofac reference to 4.7.0 + { + ctors = new ConstructorInfo[0]; + } - if (_autowireProperties) - { - var logProperties = ra.LimitType - .GetRuntimeProperties() - .Where(c => c.CanWrite && c.PropertyType == typeof(ILogger) && c.SetMethod.IsPublic && !c.SetMethod.IsStatic) - .ToArray(); + var usesLogger = + ctors.SelectMany(ctor => ctor.GetParameters()).Any(pi => pi.ParameterType == typeof(ILogger)); - if (logProperties.Any()) + if (_autowireProperties) { - targetProperties = logProperties; - usesLogger = true; + var logProperties = ra.LimitType + .GetRuntimeProperties() + .Where(c => c.CanWrite && c.PropertyType == typeof(ILogger) && c.SetMethod.IsPublic && + !c.SetMethod.IsStatic) + .ToArray(); + + if (logProperties.Any()) + { + targetProperties = logProperties; + usesLogger = true; + } } - } - // Ignore components known to be without logger dependencies - if (!usesLogger) - return; - } - else - { - if (_onlyKnownConsumers) + // Ignore components known to be without logger dependencies + if (!usesLogger) + return; + break; + case ProvidedInstanceActivator _: + //we cannot and should not affect provided instances return; + default: + //most likely a DelegateActivator - or a custom one + if (_alwaysSupplyParameter) + break; + else + return; } registration.Preparing += (sender, args) => diff --git a/src/AutofacSerilogIntegration/SerilogContainerBuilderExtensions.cs b/src/AutofacSerilogIntegration/SerilogContainerBuilderExtensions.cs index cf4a911..0a03acc 100644 --- a/src/AutofacSerilogIntegration/SerilogContainerBuilderExtensions.cs +++ b/src/AutofacSerilogIntegration/SerilogContainerBuilderExtensions.cs @@ -19,15 +19,15 @@ public static class SerilogContainerBuilderExtensions /// If true, properties on reflection-based components of type will /// be injected. /// - /// - /// If true, only the registrations that can be verified to use will be modified to access the logger, - /// thus avoiding unnecessary logger calls. - /// + /// + /// If true, the parameter containing will be injected even when registration cannot be verified to use it, + /// such as . + /// /// An object supporting method chaining. - public static IModuleRegistrar RegisterLogger(this ContainerBuilder builder, ILogger logger = null, bool autowireProperties = false, bool dispose = false, bool onlyKnownConsumers = false) + public static IModuleRegistrar RegisterLogger(this ContainerBuilder builder, ILogger logger = null, bool autowireProperties = false, bool dispose = false, bool alwaysSupplyParameter = false) { if (builder == null) throw new ArgumentNullException(nameof(builder)); - return builder.RegisterModule(new ContextualLoggingModule(logger, autowireProperties, dispose, onlyKnownConsumers)); + return builder.RegisterModule(new ContextualLoggingModule(logger, autowireProperties, dispose, alwaysSupplyParameter)); } } } diff --git a/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs b/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs index 271053a..6ff1bec 100644 --- a/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs +++ b/test/AutofacSerilogIntegration.Tests/ActivatorTests.cs @@ -1,5 +1,7 @@ using System; +using System.Linq; using Autofac; +using Autofac.Core; using Moq; using Serilog; using Xunit; @@ -16,14 +18,14 @@ public ActivatorTests() _logger.SetReturnsDefault(_logger.Object); } - private void ResolveInstance(Action configureContainer, bool? onlyKnownConsumers) + private void ResolveInstance(Action configureContainer, bool? alwaysSupplyParameter) { var containerBuilder = new ContainerBuilder(); - if (onlyKnownConsumers == null) + if (alwaysSupplyParameter == null) containerBuilder.RegisterLogger(_logger.Object); else - containerBuilder.RegisterLogger(_logger.Object, onlyKnownConsumers: onlyKnownConsumers.Value); + containerBuilder.RegisterLogger(_logger.Object, alwaysSupplyParameter: alwaysSupplyParameter.Value); containerBuilder.RegisterType>(); configureContainer(containerBuilder); @@ -40,9 +42,9 @@ private void VerifyLoggerCreation(Func times) [InlineData(null)] [InlineData(false)] [InlineData(true)] - public void ReflectionActivator_DependencyWithLogger_ShouldCreateLogger(bool? onlyKnownConsumers) + public void ReflectionActivator_DependencyWithLogger_ShouldCreateLogger(bool? alwaysSupplyParameter) { - ResolveInstance(containerBuilder => containerBuilder.RegisterType(), onlyKnownConsumers); + ResolveInstance(containerBuilder => containerBuilder.RegisterType(), alwaysSupplyParameter); VerifyLoggerCreation(Times.AtLeastOnce); } @@ -50,44 +52,62 @@ public void ReflectionActivator_DependencyWithLogger_ShouldCreateLogger(bool? on [InlineData(null)] [InlineData(false)] [InlineData(true)] - public void ReflectionActivator_DependencyWithoutLogger_ShouldNotCreateLogger(bool? onlyKnownConsumers) + public void ReflectionActivator_DependencyWithoutLogger_ShouldNotCreateLogger(bool? alwaysSupplyParameter) { - ResolveInstance(containerBuilder => containerBuilder.RegisterType(), onlyKnownConsumers); + ResolveInstance(containerBuilder => containerBuilder.RegisterType(), alwaysSupplyParameter); VerifyLoggerCreation(Times.Never); } [Theory] [InlineData(null)] [InlineData(false)] - //legacy behavior - public void Default_ProvidedInstanceActivator_DependencyWithoutLogger_CreatesLogger(bool? onlyKnownConsumers) + [InlineData(true)] + public void ProvidedInstanceActivator_ShouldNotCreateLogger(bool? alwaysSupplyParameter) { - ResolveInstance(containerBuilder => containerBuilder.RegisterInstance(new DependencyWithoutLogger()), onlyKnownConsumers); - VerifyLoggerCreation(Times.AtLeastOnce); + ResolveInstance(containerBuilder => containerBuilder.RegisterInstance(new DependencyWithoutLogger()), alwaysSupplyParameter); + VerifyLoggerCreation(Times.Never); } [Theory] [InlineData(null)] [InlineData(false)] - //legacy behavior - public void Default_DelegateActivator_DependencyWithoutLogger_CreatesLogger(bool? onlyKnownConsumers) + public void DelegateActivator_ShouldNotCreateLogger(bool? alwaysSupplyParameter) { - ResolveInstance(containerBuilder => containerBuilder.Register(_ => new DependencyWithoutLogger()), onlyKnownConsumers); - VerifyLoggerCreation(Times.AtLeastOnce); + ResolveInstance(containerBuilder => containerBuilder.Register(_ => new DependencyWithoutLogger()), alwaysSupplyParameter); + VerifyLoggerCreation(Times.Never); } - [Fact] - public void OnlyKnownCustomers_ProvidedInstanceActivator_DependencyWithoutLogger_ShouldNotCreateLogger() + [Theory] + [InlineData(null)] + [InlineData(false)] + public void DelegateActivator_ShouldNotPassParameter(bool? alwaysSupplyParameter) { - ResolveInstance(containerBuilder => containerBuilder.RegisterInstance(new DependencyWithoutLogger()), onlyKnownConsumers: true); - VerifyLoggerCreation(Times.Never); + Parameter[] parameters = null; + ResolveInstance(containerBuilder => containerBuilder.Register((_, pp) => + { + parameters = pp.ToArray(); + return new DependencyWithoutLogger(); + }), alwaysSupplyParameter); + Assert.NotNull(parameters); + Assert.Empty(parameters); } - [Fact] - public void OnlyKnownCustomers_DelegateActivator_DependencyWithoutLogger_ShouldNotCreateLogger() + [Theory] + [InlineData(true)] + public void DelegateActivator_WhenForced_ShouldPassParameter(bool? alwaysSupplyParameter) { - ResolveInstance(containerBuilder => containerBuilder.Register(_ => new DependencyWithoutLogger()), onlyKnownConsumers: true); - VerifyLoggerCreation(Times.Never); + Parameter[] parameters = null; + ResolveInstance(containerBuilder => containerBuilder.Register((_, pp) => + { + parameters = pp.ToArray(); + return new DependencyWithoutLogger(); + }), alwaysSupplyParameter); + Assert.NotNull(parameters); + var value = Assert.Single(parameters + .OfType() + .Where(p => p.Type == typeof(ILogger)) + )?.Value; + Assert.IsAssignableFrom(value); } private class Component From bbcff8aee91902b169899613182052f4374d80b5 Mon Sep 17 00:00:00 2001 From: Sergey Rogovtsev Date: Sat, 4 Jul 2020 11:39:38 +0300 Subject: [PATCH 4/5] We already moved to Autofac 5, let's cleanup some old code --- src/AutofacSerilogIntegration/ContextualLoggingModule.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/AutofacSerilogIntegration/ContextualLoggingModule.cs b/src/AutofacSerilogIntegration/ContextualLoggingModule.cs index 6f92f2e..ca8eefe 100644 --- a/src/AutofacSerilogIntegration/ContextualLoggingModule.cs +++ b/src/AutofacSerilogIntegration/ContextualLoggingModule.cs @@ -107,7 +107,7 @@ protected override void AttachToComponentRegistration(IComponentRegistryBuilder { ctors = ra.ConstructorFinder.FindConstructors(ra.LimitType); } - catch (Exception ex) when (ex.GetType().Name == "NoConstructorsFoundException") // Avoid needing to upgrade our Autofac reference to 4.7.0 + catch (NoConstructorsFoundException) { ctors = new ConstructorInfo[0]; } From edaabf67a40a1628bd743f2e6493e4add8d45868 Mon Sep 17 00:00:00 2001 From: Sergey Rogovtsev Date: Sat, 4 Jul 2020 11:41:51 +0300 Subject: [PATCH 5/5] Tidying up --- src/AutofacSerilogIntegration/ContextualLoggingModule.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/AutofacSerilogIntegration/ContextualLoggingModule.cs b/src/AutofacSerilogIntegration/ContextualLoggingModule.cs index ca8eefe..72fd229 100644 --- a/src/AutofacSerilogIntegration/ContextualLoggingModule.cs +++ b/src/AutofacSerilogIntegration/ContextualLoggingModule.cs @@ -119,8 +119,7 @@ protected override void AttachToComponentRegistration(IComponentRegistryBuilder { var logProperties = ra.LimitType .GetRuntimeProperties() - .Where(c => c.CanWrite && c.PropertyType == typeof(ILogger) && c.SetMethod.IsPublic && - !c.SetMethod.IsStatic) + .Where(c => c.CanWrite && c.PropertyType == typeof(ILogger) && c.SetMethod.IsPublic && !c.SetMethod.IsStatic) .ToArray(); if (logProperties.Any())