10.0.1 Release

Directory.Version.props

@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
     <!-- This must match the major and minor components of the referenced Microsoft.Extensions.Configuration package. -->
-    <VersionPrefix>10.0.0</VersionPrefix>
+    <VersionPrefix>10.0.1</VersionPrefix>
   </PropertyGroup>
 </Project>

README.md

@@ -313,6 +313,8 @@ Some Serilog packages require a reference to a logger configuration object. The
 },
 ```
 
+The same nested pattern applies to wrapping sinks such as `Conditional` (from _[Serilog.Expressions](https://github.com/serilog/serilog-expressions)_), `FallbackChain`, and `Fallible` — see the [sample `appsettings.json`](sample/Sample/appsettings.json) for working examples.
+
 ### Destructuring
 
 Destructuring means extracting pieces of information from an object and create properties with values; Serilog offers the `@` [structure-capturing operator](https://github.com/serilog/serilog/wiki/Structured-Data#preserving-object-structure). In case there is a need to customize the way log events are serialized (e.g., hide property values or replace them with something else), one can define several destructuring policies, like this:

sample/Sample/AlwaysFailingSink.cs

@@ -0,0 +1,13 @@
+using Serilog.Core;
+using Serilog.Events;
+
+namespace Sample;
+
+public class AlwaysFailingSink : ILogEventSink
+{
+    public void Emit(LogEvent logEvent)
+    {
+        throw new InvalidOperationException(
+            "AlwaysFailingSink always throws so the sample can demonstrate fallback/failure-listener behavior.");
+    }
+}

sample/Sample/SampleFailureListener.cs

@@ -0,0 +1,22 @@
+using Serilog.Core;
+using Serilog.Debugging;
+using Serilog.Events;
+
+namespace Sample;
+
+public class SampleFailureListener : ILoggingFailureListener
+{
+    public void OnLoggingFailed(
+        object sender,
+        LoggingFailureKind kind,
+        string message,
+        IReadOnlyCollection<LogEvent>? events,
+        Exception? exception)
+    {
+        var exceptionDetail = exception is null
+            ? string.Empty
+            : $" — {exception.GetType().Name}: {exception.Message}";
+        SelfLog.WriteLine(
+            $"[SampleFailureListener] {kind} failure from {sender.GetType().Name}: {message} ({events?.Count ?? 0} events){exceptionDetail}");
+    }
+}

sample/Sample/appsettings.json

@@ -4,7 +4,7 @@
     "LevelSwitches": { "controlSwitch": "Verbose" },
     "FilterSwitches": { "$filterSwitch": "Application = 'Sample'" },
     "MinimumLevel": {
-      "Default": "Debug",
+      "ControlledBy": "$controlSwitch",
       "Override": {
         "Microsoft": "Warning",
         "MyApp.Something.Tricky": "Verbose"
@@ -37,7 +37,10 @@
             "Name": "File",
             "Args": {
               "path": "%TEMP%/Logs/serilog-configuration-sample.txt",
-              "outputTemplate": "{Timestamp:o} [{Level:u3}] ({Application}/{MachineName}/{ThreadId}/{ThreadName}) {Message}{NewLine}{Exception}"
+              "formatter": {
+                "type": "Serilog.Templates.ExpressionTemplate, Serilog.Expressions",
+                "template": "{@t:o} [{@l:u3}] ({Application}/{MachineName}/{ThreadId}/{ThreadName}) {@m}\n{@x}"
+              }
             }
           }
         ]
@@ -46,7 +49,7 @@
     "WriteTo:ConditionalSink": {
       "Name": "Conditional",
       "Args": {
-        "expression": "@Level in ['Error', 'Fatal']",
+        "expression": "@l in ['Error', 'Fatal']",
         "configureSink": [
           {
             "Name": "File",
@@ -63,6 +66,43 @@
         ]
       }
     },
+    "WriteTo:FallbackChain": {
+      "Name": "FallbackChain",
+      "Args": {
+        "configureSink": [
+          {
+            "Name": "Sink",
+            "Args": {
+              "sink": { "type": "Sample.AlwaysFailingSink, Sample" }
+            }
+          }
+        ],
+        "configureFallback": [
+          {
+            "Name": "Console",
+            "Args": {
+              "outputTemplate": "[fallback {Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}"
+            }
+          }
+        ]
+      }
+    },
+    "WriteTo:Fallible": {
+      "Name": "Fallible",
+      "Args": {
+        "configureSink": [
+          {
+            "Name": "Sink",
+            "Args": {
+              "sink": { "type": "Sample.AlwaysFailingSink, Sample" }
+            }
+          }
+        ],
+        "failureListener": {
+          "type": "Sample.SampleFailureListener, Sample"
+        }
+      }
+    },
     "Enrich": [
       "FromLogContext",
       "WithThreadId",
@@ -79,6 +119,13 @@
           "expression": "Application = 'Sample'",
           "configureEnricher": [ "WithMachineName" ]
         }
+      },
+      {
+        "Name": "WithComputed",
+        "Args": {
+          "name": "ShortContext",
+          "expression": "coalesce(SourceContext, '<no-context>')"
+        }
       }
     ],
     "Properties": {
@@ -109,6 +156,12 @@
           "switch": "$filterSwitch"
         }
       },
+      {
+        "Name": "ByExcluding",
+        "Args": {
+          "expression": "Application = 'OtherApp'"
+        }
+      },
       {
         "Name": "With",
         "Args": {
@@ -118,6 +171,14 @@
           }
         }
       }
+    ],
+    "AuditTo": [
+      {
+        "Name": "Console",
+        "Args": {
+          "outputTemplate": "[AUDIT {Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}"
+        }
+      }
     ]
   }
 }

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

@@ -403,10 +403,12 @@ static bool HasImplicitValueWhenNotSpecified(ParameterInfo paramInfo)
     {
         return paramInfo.HasDefaultValue
            // parameters of type IConfiguration are implicitly populated with provided Configuration
-           || paramInfo.ParameterType == typeof(IConfiguration);
+           || paramInfo.ParameterType == typeof(IConfiguration)
+           || paramInfo.IsDefined(typeof(ParamArrayAttribute), false)
+           || paramInfo.CustomAttributes.Any(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.ParamCollectionAttribute");
     }
 
-    object? GetImplicitValueForNotSpecifiedKey(ParameterInfo parameter, MethodInfo methodToInvoke)
+    internal object? GetImplicitValueForNotSpecifiedKey(ParameterInfo parameter, MethodInfo methodToInvoke)
     {
         if (!HasImplicitValueWhenNotSpecified(parameter))
         {
@@ -429,7 +431,12 @@ static bool HasImplicitValueWhenNotSpecified(ParameterInfo paramInfo)
                                                           $"This is not supported when only a `IConfigSection` has been provided. (method '{methodToInvoke}')");
         }
 
-        return parameter.DefaultValue;
+        if (parameter.IsDefined(typeof(ParamArrayAttribute), false) && parameter.ParameterType.GetElementType() is { } elementType)
+        {
+            return Array.CreateInstance(elementType, 0);
+        }
+
+        return parameter.HasDefaultValue ? parameter.DefaultValue : null;
     }
 
     internal static MethodInfo? SelectConfigurationMethod(IReadOnlyCollection<MethodInfo> candidateMethods, string name, IReadOnlyCollection<string> suppliedArgumentNames)
@@ -571,8 +578,21 @@ internal static bool IsValidSwitchName(string input)
         return Regex.IsMatch(input, LevelSwitchNameRegex);
     }
 
-    static LogEventLevel ParseLogEventLevel(string value)
-        => Enum.TryParse(value, ignoreCase: true, out LogEventLevel parsedLevel)
-            ? parsedLevel
-            : throw new InvalidOperationException($"The value {value} is not a valid Serilog level.");
+    internal static LogEventLevel ParseLogEventLevel(string value)
+    {
+        // Try parsing as LevelAlias first (handles "Off", "Minimum", "Maximum")
+        if (string.Equals(value, "Off", StringComparison.OrdinalIgnoreCase))
+            return LevelAlias.Off;
+        if (string.Equals(value, "Minimum", StringComparison.OrdinalIgnoreCase))
+            return LevelAlias.Minimum;
+        if (string.Equals(value, "Maximum", StringComparison.OrdinalIgnoreCase))
+            return LevelAlias.Maximum;
+
+        // Try parsing as LogEventLevel enum
+        if (Enum.TryParse(value, ignoreCase: true, out LogEventLevel parsedLevel))
+            return parsedLevel;
+
+        throw new InvalidOperationException($"The value {value} is not a valid Serilog level.");
+    }
+
 }

src/Serilog.Settings.Configuration/Settings/Configuration/StringArgumentValue.cs

@@ -154,6 +154,11 @@ public StringArgumentValue(string providedValue)
             }
         }
 
+        if (toType.IsArray && string.IsNullOrWhiteSpace(argumentValue))
+        {
+            return Array.CreateInstance(toType.GetElementType()!, 0);
+        }
+
         return Convert.ChangeType(argumentValue, toType, resolutionContext.ReaderOptions.FormatProvider);
     }
 

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

@@ -55,6 +55,19 @@ static LoggerConfiguration Logger(
         LoggingLevelSwitch? levelSwitch = null)
         => loggerSinkConfiguration.Logger(configureLogger, restrictedToMinimumLevel, levelSwitch);
 
+    static LoggerConfiguration FallbackChain(
+        LoggerSinkConfiguration loggerSinkConfiguration,
+        Action<LoggerSinkConfiguration> configureSink,
+        Action<LoggerSinkConfiguration> configureFallback,
+        Action<LoggerSinkConfiguration>[]? configureSubsequentFallbacks = null)
+        => loggerSinkConfiguration.FallbackChain(configureSink, configureFallback, configureSubsequentFallbacks ?? []);
+
+    static LoggerConfiguration Fallible(
+        LoggerSinkConfiguration loggerSinkConfiguration,
+        Action<LoggerSinkConfiguration> configureSink,
+        ILoggingFailureListener failureListener)
+        => loggerSinkConfiguration.Fallible(configureSink, failureListener);
+
     // .AuditTo...
     // ========
     static LoggerConfiguration Sink(

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

@@ -294,4 +294,102 @@ public void NoConfigurationRootUsedStillValid()
 
         AssertLogEventLevels(loggerConfig, LogEventLevel.Error);
     }
+
+    [Theory]
+    // Standard LogEventLevel enum values
+    [InlineData("Verbose", LogEventLevel.Verbose)]
+    [InlineData("Debug", LogEventLevel.Debug)]
+    [InlineData("Information", LogEventLevel.Information)]
+    [InlineData("Warning", LogEventLevel.Warning)]
+    [InlineData("Error", LogEventLevel.Error)]
+    [InlineData("Fatal", LogEventLevel.Fatal)]
+    // Case insensitivity
+    [InlineData("verbose", LogEventLevel.Verbose)]
+    [InlineData("INFORMATION", LogEventLevel.Information)]
+    [InlineData("warning", LogEventLevel.Warning)]
+    // LevelAlias values
+    [InlineData("Off", LevelAlias.Off)]
+    [InlineData("off", LevelAlias.Off)]
+    [InlineData("OFF", LevelAlias.Off)]
+    [InlineData("Minimum", LevelAlias.Minimum)]
+    [InlineData("minimum", LevelAlias.Minimum)]
+    [InlineData("Maximum", LevelAlias.Maximum)]
+    [InlineData("maximum", LevelAlias.Maximum)]
+    public void ParseLogEventLevelHandlesAllLevelValues(string value, LogEventLevel expected)
+    {
+        var result = ConfigurationReader.ParseLogEventLevel(value);
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData("InvalidLevel")]
+    [InlineData("")]
+    [InlineData("None")]
+    public void ParseLogEventLevelThrowsForInvalidValues(string value)
+    {
+        Assert.Throws<InvalidOperationException>(() => ConfigurationReader.ParseLogEventLevel(value));
+    }
+
+    [Fact]
+    public void ParamsStringArrayParameter_WithNoArgsSupplied_IsMatchedAsOptional()
+    {
+        var candidateMethods = typeof(DummyLoggerConfigurationExtensions)
+            .GetTypeInfo()
+            .DeclaredMethods
+            .ToList();
+
+        var selected = ConfigurationReader.SelectConfigurationMethod(
+            candidateMethods, "DummyParamsArray", Array.Empty<string>());
+
+        Assert.NotNull(selected);
+    }
+
+    [Fact]
+    public void ParamsStringArrayParameter_ImplicitValueIsEmptyArray()
+    {
+        var reader = new ConfigurationReader(
+            JsonStringConfigSource.LoadSection("{}", "Serilog"),
+            AssemblyFinder.ForSource(ConfigurationAssemblySource.UseLoadedAssemblies),
+            new ConfigurationReaderOptions());
+
+        var method = typeof(DummyLoggerConfigurationExtensions).GetMethod("DummyParamsArray")!;
+        var param = method.GetParameters().Last(); // params string[] values
+
+        var result = reader.GetImplicitValueForNotSpecifiedKey(param, method);
+
+        var array = Assert.IsType<string[]>(result);
+        Assert.Empty(array);
+    }
+
+    [Fact]
+    public void ParamsEnumerableParameter_GracefullyReturnsDefaultValue()
+    {
+        var reader = new ConfigurationReader(
+            JsonStringConfigSource.LoadSection("{}", "Serilog"),
+            AssemblyFinder.ForSource(ConfigurationAssemblySource.UseLoadedAssemblies),
+            new ConfigurationReaderOptions());
+
+        var method = typeof(DummyLoggerConfigurationExtensions).GetMethod("DummyParamsEnumerable")!;
+        var param = method.GetParameters().Last(); // params IEnumerable<string>
+
+        var result = reader.GetImplicitValueForNotSpecifiedKey(param, method);
+
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public void ParamsSpanParameter_GracefullyReturnsDefaultValue()
+    {
+        var reader = new ConfigurationReader(
+            JsonStringConfigSource.LoadSection("{}", "Serilog"),
+            AssemblyFinder.ForSource(ConfigurationAssemblySource.UseLoadedAssemblies),
+            new ConfigurationReaderOptions());
+
+        var method = typeof(DummyLoggerConfigurationExtensions).GetMethod("DummyParamsSpan")!;
+        var param = method.GetParameters().Last(); // params ReadOnlySpan<string>
+
+        var result = reader.GetImplicitValueForNotSpecifiedKey(param, method);
+
+        Assert.Null(result);
+    }
 }