Add support for AuditTo.Sink()

Support for `AuditTo.Sink(ILogEventSink logEventSink, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, LoggingLevelSwitch levelSwitch = null)`

Author: tsimbalar

src/Serilog.Settings.Configuration/Settings/Configuration/ConfigurationReader.cs

@@ -374,7 +374,8 @@ internal static IList<MethodInfo> FindSinkConfigurationMethods(IReadOnlyCollecti
         internal static IList<MethodInfo> FindAuditSinkConfigurationMethods(IReadOnlyCollection<Assembly> configurationAssemblies)
         {
             var found = FindConfigurationExtensionMethods(configurationAssemblies, typeof(LoggerAuditSinkConfiguration));
-
+            if (configurationAssemblies.Contains(typeof(LoggerAuditSinkConfiguration).GetTypeInfo().Assembly))
+                found.AddRange(SurrogateConfigurationMethods.AuditTo);
             return found;
         }
 

src/Serilog.Settings.Configuration/Settings/Configuration/SurrogateConfigurationMethods.cs

@@ -27,6 +27,14 @@ public static IEnumerable<MethodInfo> WriteTo
             }
         }
 
+        public static IEnumerable<MethodInfo> AuditTo
+        {
+            get
+            {
+                yield return GetSurrogateConfigurationMethod<LoggerAuditSinkConfiguration, ILogEventSink, LoggingLevelSwitch>((c, sink, s) => Sink(c, sink, LevelAlias.Minimum, s));
+            }
+        }
+
         public static IEnumerable<MethodInfo> Filter
         {
             get
@@ -66,7 +74,9 @@ invocation expressions as surrogates so that SelectConfigurationMethod
         has a way to match and invoke these instance methods.
         */
 
-        internal static LoggerConfiguration Sink(
+        // .WriteTo...
+        // ========
+        static LoggerConfiguration Sink(
             LoggerSinkConfiguration loggerSinkConfiguration,
             ILogEventSink sink,
             LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
@@ -75,10 +85,32 @@ internal static LoggerConfiguration Sink(
             return loggerSinkConfiguration.Sink(sink, restrictedToMinimumLevel, levelSwitch);
         }
 
+        static LoggerConfiguration Logger(
+            LoggerSinkConfiguration loggerSinkConfiguration,
+            Action<LoggerConfiguration> configureLogger,
+            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
+            LoggingLevelSwitch levelSwitch = null)
+            => loggerSinkConfiguration.Logger(configureLogger, restrictedToMinimumLevel, levelSwitch);
+
+        // .AuditTo...
+        // ========
+        static LoggerConfiguration Sink(
+            LoggerAuditSinkConfiguration auditSinkConfiguration,
+            ILogEventSink sink,
+            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
+            LoggingLevelSwitch levelSwitch = null)
+        {
+            return auditSinkConfiguration.Sink(sink, restrictedToMinimumLevel, levelSwitch);
+        }
+
+        // .Filter...
+        // =======
         // TODO: add overload for array argument (ILogEventEnricher[])
         static LoggerConfiguration With(LoggerFilterConfiguration loggerFilterConfiguration, ILogEventFilter filter)
             => loggerFilterConfiguration.With(filter);
 
+        // .Destructure...
+        // ============
         // TODO: add overload for array argument (IDestructuringPolicy[])
         static LoggerConfiguration With(LoggerDestructuringConfiguration loggerDestructuringConfiguration, IDestructuringPolicy policy)
             => loggerDestructuringConfiguration.With(policy);
@@ -95,15 +127,10 @@ static LoggerConfiguration ToMaximumCollectionCount(LoggerDestructuringConfigura
         static LoggerConfiguration AsScalar(LoggerDestructuringConfiguration loggerDestructuringConfiguration, Type scalarType)
             => loggerDestructuringConfiguration.AsScalar(scalarType);
 
+        // .Enrich...
+        // =======
         static LoggerConfiguration FromLogContext(LoggerEnrichmentConfiguration loggerEnrichmentConfiguration)
             => loggerEnrichmentConfiguration.FromLogContext();
 
-        // Unlike the other configuration methods, Logger is an instance method rather than an extension.
-        static LoggerConfiguration Logger(
-            LoggerSinkConfiguration loggerSinkConfiguration,
-            Action<LoggerConfiguration> configureLogger,
-            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
-            LoggingLevelSwitch levelSwitch = null)
-            => loggerSinkConfiguration.Logger(configureLogger, restrictedToMinimumLevel, levelSwitch);
     }
 }

test/Serilog.Settings.Configuration.Tests/ConfigurationSettingsTests.cs

@@ -881,5 +881,86 @@ public void WriteToSinkIsAppliedWithCustomSinkAndLevelSwitch()
 
             Assert.Single(DummyRollingFileSink.Emitted);
         }
+
+        
+        [Fact]
+        public void AuditToSinkIsAppliedWithCustomSink()
+        {
+            var json = $@"{{
+                ""Serilog"": {{
+                    ""Using"": [""TestDummies""],
+                    ""AuditTo"": [
+                    {{
+                        ""Name"": ""Sink"",
+                        ""Args"": {{
+                            ""sink"": ""{typeof(DummyRollingFileSink).AssemblyQualifiedName}""
+                        }}
+                    }}]
+                }}
+            }}";
+
+            var log = ConfigFromJson(json)
+                .CreateLogger();
+
+            DummyRollingFileSink.Reset();
+            log.Write(Some.InformationEvent());
+
+            Assert.Single(DummyRollingFileSink.Emitted);
+        }
+
+        [Fact]
+        public void AuditToSinkIsAppliedWithCustomSinkAndMinimumLevel()
+        {
+            var json = $@"{{
+                ""Serilog"": {{
+                    ""Using"": [""TestDummies""],
+                    ""AuditTo"": [
+                    {{
+                        ""Name"": ""Sink"",
+                        ""Args"": {{
+                            ""sink"": ""{typeof(DummyRollingFileSink).AssemblyQualifiedName}"",
+                            ""restrictedToMinimumLevel"": ""Warning""
+                        }}
+                    }}]
+                }}
+            }}";
+
+            var log = ConfigFromJson(json)
+                .CreateLogger();
+
+            DummyRollingFileSink.Reset();
+            log.Write(Some.InformationEvent());
+            log.Write(Some.WarningEvent());
+
+            Assert.Single(DummyRollingFileSink.Emitted);
+        }
+
+        [Fact]
+        public void AuditToSinkIsAppliedWithCustomSinkAndLevelSwitch()
+        {
+            var json = $@"{{
+                ""Serilog"": {{
+                    ""Using"": [""TestDummies""],
+                    ""LevelSwitches"": {{""$switch1"": ""Warning"" }},
+                    ""AuditTo"": [
+                    {{
+                        ""Name"": ""Sink"",
+                        ""Args"": {{
+                            ""sink"": ""{typeof(DummyRollingFileSink).AssemblyQualifiedName}"",
+                            ""levelSwitch"": ""$switch1""
+                        }}
+                    }}]
+                }}
+            }}";
+
+            var log = ConfigFromJson(json)
+                .CreateLogger();
+
+            DummyRollingFileSink.Reset();
+            log.Write(Some.InformationEvent());
+            log.Write(Some.WarningEvent());
+
+            Assert.Single(DummyRollingFileSink.Emitted);
+        }
     }
 }