Updates for Serilog 4

Build.ps1

@@ -1,31 +1,42 @@
+Write-Output "build: Build started"
+
 Push-Location $PSScriptRoot
 
-if(Test-Path .\artifacts) { Remove-Item .\artifacts -Force -Recurse }
+if(Test-Path .\artifacts) {
+	Write-Output "build: Cleaning ./artifacts"
+	Remove-Item ./artifacts -Force -Recurse
+}
 
 & dotnet restore --no-cache
 
-$branch = @{ $true = $env:APPVEYOR_REPO_BRANCH; $false = $(git symbolic-ref --short -q HEAD) }[$env:APPVEYOR_REPO_BRANCH -ne $NULL];
-$revision = @{ $true = "{0:00000}" -f [convert]::ToInt32("0" + $env:APPVEYOR_BUILD_NUMBER, 10); $false = "local" }[$env:APPVEYOR_BUILD_NUMBER -ne $NULL];
-$suffix = @{ $true = ""; $false = "$branch-$revision"}[$branch -eq "master" -and $revision -ne "local"]
+$branch = @{ $true = $env:APPVEYOR_REPO_BRANCH; $false = $(git symbolic-ref --short -q HEAD) }[$NULL -ne $env:APPVEYOR_REPO_BRANCH];
+$revision = @{ $true = "{0:00000}" -f [convert]::ToInt32("0" + $env:APPVEYOR_BUILD_NUMBER, 10); $false = "local" }[$NULL -ne $env:APPVEYOR_BUILD_NUMBER];
+$suffix = @{ $true = ""; $false = "$($branch.Substring(0, [math]::Min(10,$branch.Length)))-$revision"}[$branch -eq "main" -and $revision -ne "local"]
+
+Write-Output "build: Package version suffix is $suffix"
 
-foreach ($src in ls src/Serilog.*) {
+foreach ($src in Get-ChildItem src/*) {
     Push-Location $src
 
-    if($suffix) {
-        & dotnet pack -c Release -o ..\..\.\artifacts --version-suffix=$suffix --include-source
+	Write-Output "build: Packaging project in $src"
+
+    if ($suffix) {
+        & dotnet pack -c Release /p:ContinuousIntegrationBuild=True -o ../../artifacts --version-suffix=$suffix
     } else {
-        & dotnet pack -c Release -o ..\..\.\artifacts --include-source
+        & dotnet pack -c Release /p:ContinuousIntegrationBuild=True -o ../../artifacts
     }
-    if($LASTEXITCODE -ne 0) { exit 1 }    
+    if($LASTEXITCODE -ne 0) { throw "Packaging failed" }
 
     Pop-Location
 }
 
-foreach ($test in ls test/Serilog.*.Tests) {
+foreach ($test in Get-ChildItem test/*.Tests) {
     Push-Location $test
 
+	Write-Output "build: Testing project in $test"
+
     & dotnet test -c Release
-    if($LASTEXITCODE -ne 0) { exit 2 }
+    if($LASTEXITCODE -ne 0) { throw "Testing failed" }
 
     Pop-Location
 }

appveyor.yml

@@ -1,22 +1,24 @@
 version: '{build}'
 skip_tags: true
-image: Visual Studio 2019
+image:
+  - Visual Studio 2022
 build_script:
-- ps: ./Build.ps1
+  - pwsh: ./Build.ps1
 test: off
 artifacts:
-- path: artifacts/Serilog.*.nupkg
+  - path: artifacts/Serilog.*.nupkg
+  - path: artifacts/Serilog.*.snupkg
 deploy:
-- provider: NuGet
-  api_key:
-    secure: K3/810hkTO6rd2AEHVkUQAadjGmDREus9k96QHu6hxrA1/wRTuAJemHMKtVVgIvf
-  skip_symbols: true
-  on:
-    branch: /^(master|dev)$/
-- provider: GitHub
-  auth_token:
-    secure: p4LpVhBKxGS5WqucHxFQ5c7C8cP74kbNB0Z8k9Oxx/PMaDQ1+ibmoexNqVU5ZlmX
-  artifact: /Serilog.*\.nupkg/
-  tag: v$(appveyor_build_version)
-  on:
-    branch: master
+  - provider: NuGet
+    api_key:
+      secure: sDnchSg4TZIOK7oIUI6BJwFPNENTOZrGNsroGO1hehLJSvlHpFmpTwiX8+bgPD+Q
+    on:
+      branch: /^(main|dev)$/
+  - provider: GitHub
+    auth_token:
+      secure: p4LpVhBKxGS5WqucHxFQ5c7C8cP74kbNB0Z8k9Oxx/PMaDQ1+ibmoexNqVU5ZlmX
+    artifact: /Serilog.*(\.|\.s)nupkg/
+    tag: v$(appveyor_build_version)
+    on:
+      branch: main
+      

src/Serilog.Sinks.Map/Serilog.Sinks.Map.csproj

@@ -1,32 +1,43 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <Description>A Serilog sink wrapper that dispatches events based on a property value.</Description>
-    <VersionPrefix>1.0.3</VersionPrefix>
-    <RootNamespace>Serilog</RootNamespace>
-    <Authors>Serilog Contributors</Authors>
-    <Copyright>Copyright © Serilog Contributors</Copyright>
-    <TargetFrameworks>netstandard1.0;netstandard2.0;net5.0</TargetFrameworks>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <AssemblyOriginatorKeyFile>../../assets/Serilog.snk</AssemblyOriginatorKeyFile>
-    <SignAssembly>true</SignAssembly>
-    <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
-    <PackageTags>serilog</PackageTags>
-    <PackageIcon>icon.png</PackageIcon>
-    <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
-    <PackageProjectUrl>https://github.com/serilog/serilog-sinks-map</PackageProjectUrl>
-    <RepositoryUrl>https://github.com/serilog/serilog-sinks-map</RepositoryUrl>
-    <RepositoryType>git</RepositoryType>
-    <GenerateAssemblyVersionAttribute>true</GenerateAssemblyVersionAttribute>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Serilog" Version="2.8.0" />
-  </ItemGroup>
+    <PropertyGroup>
+        <Description>A Serilog sink wrapper that dispatches events based on a property value.</Description>
+        <VersionPrefix>2.0.0</VersionPrefix>
+        <RootNamespace>Serilog</RootNamespace>
+        <Authors>Serilog Contributors</Authors>
+        <Copyright>Copyright © Serilog Contributors</Copyright>
+        <!-- .NET Framework version targeting is frozen at these two TFMs. -->
+        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT'">net471;net462</TargetFrameworks>
+        <!-- Policy is to trim TFM-specific builds to `netstandard2.0`, `net6.0`,
+        all active LTS versions, and optionally the latest RTM version, when releasing new
+        major Serilog versions. -->
+        <TargetFrameworks>$(TargetFrameworks);net8.0;net6.0;netstandard2.0</TargetFrameworks>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <AssemblyOriginatorKeyFile>../../assets/Serilog.snk</AssemblyOriginatorKeyFile>
+        <SignAssembly>true</SignAssembly>
+        <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
+        <PackageTags>serilog</PackageTags>
+        <PackageIcon>icon.png</PackageIcon>
+        <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
+        <PackageProjectUrl>https://github.com/serilog/serilog-sinks-map</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/serilog/serilog-sinks-map</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+        <GenerateAssemblyVersionAttribute>true</GenerateAssemblyVersionAttribute>
+        <LangVersion>latest</LangVersion>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <PackageReadmeFile>README.md</PackageReadmeFile>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
 
-  <ItemGroup>
-    <None Include="..\..\assets\icon.png" Pack="true" Visible="false" PackagePath="" />
-  </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="Serilog" Version="4.0.0"/>
+        <PackageReference Include="Nullable" Version="1.3.1" PrivateAssets="all" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <None Include="..\..\assets\icon.png" Pack="true" Visible="false" PackagePath=""/>
+        <None Include="..\..\README.md" Pack="true" Visible="false" PackagePath=""/>
+    </ItemGroup>
 
 </Project>

src/Serilog.Sinks.Map/Sinks/Map/MappedSink`1.cs

@@ -12,134 +12,117 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
+using System.Diagnostics.CodeAnalysis;
 using Serilog.Configuration;
 using Serilog.Core;
 using Serilog.Events;
 
-namespace Serilog.Sinks.Map
+namespace Serilog.Sinks.Map;
+
+/// <summary>
+/// A function delegate to select a key value given a log event, if exists.
+/// </summary>
+/// <typeparam name="TKey">The type of the key value.</typeparam>
+/// <param name="logEvent">The log event.</param>
+/// <param name="key">The selected key.</param>
+/// <returns>true, if a key can be selected, or false, otherwise.</returns>
+public delegate bool KeySelector<TKey>(LogEvent logEvent, [MaybeNull] out TKey key);
+
+class MappedSink<TKey> : ILogEventSink, IDisposable
 {
-    /// <summary>
-    /// A function delegate to select a key value given a log event, if exists.
-    /// </summary>
-    /// <typeparam name="TKey">The type of the key value.</typeparam>
-    /// <param name="logEvent">The log event.</param>
-    /// <param name="key">The selected key.</param>
-    /// <returns>true, if a key can be selected, or false, otherwise.</returns>
-    public delegate bool KeySelector<TKey>(LogEvent logEvent, out TKey key);
+    readonly KeySelector<TKey> _keySelector;
+    readonly Action<TKey, LoggerSinkConfiguration> _configure;
+    readonly int? _sinkMapCountLimit;
+    readonly object _sync = new();
+    readonly Dictionary<KeyValuePair<TKey, bool>, ILogEventSink> _sinkMap = new();
+    bool _disposed;
+
+    public MappedSink(KeySelector<TKey> keySelector,
+        Action<TKey, LoggerSinkConfiguration> configure,
+        int? sinkMapCountLimit)
+    {
+        _keySelector = keySelector;
+        _configure = configure;
+        _sinkMapCountLimit = sinkMapCountLimit;
+    }
 
-    class MappedSink<TKey> : ILogEventSink, IDisposable
+    // All writes are synchronized, even though this could be avoided in a few cases; the reasoning behind this is that
+    // changes in synchronization behavior between writes and with different map count limits could lead to surprises
+    // when using the sink with log files, which are one of the main use cases. Since most sinks already synchronize
+    // writes or offload work to background threads, this is a reasonable trade-off.
+    public void Emit(LogEvent logEvent)
     {
-        readonly KeySelector<TKey> _keySelector;
-        readonly Action<TKey, LoggerSinkConfiguration> _configure;
-        readonly int? _sinkMapCountLimit;
-        readonly object _sync = new object();
-        readonly Dictionary<KeyValuePair<TKey, bool>, ILogEventSink> _sinkMap = new Dictionary<KeyValuePair<TKey, bool>, ILogEventSink>();
-        bool _disposed;
+        if (!_keySelector(logEvent, out var keyValue))
+            return;
 
-        public MappedSink(KeySelector<TKey> keySelector,
-                          Action<TKey, LoggerSinkConfiguration> configure,
-                          int? sinkMapCountLimit)
-        {
-            _keySelector = keySelector;
-            _configure = configure;
-            _sinkMapCountLimit = sinkMapCountLimit;
-        }
+        var key = new KeyValuePair<TKey, bool>(keyValue!, false);
 
-        // All writes are synchronized, even though this could be avoided in a few cases; the reasoning behind this is that
-        // changes in synchronization behavior between writes and with different map count limits could lead to surprises
-        // when using the sink with log files, which are one of the main use cases. Since most sinks already synchronize
-        // writes or offload work to background threads, this is a reasonable trade-off.
-        public void Emit(LogEvent logEvent)
+        lock (_sync)
         {
-            if (!_keySelector(logEvent, out var keyValue))
-                return;
-
-            var key = new KeyValuePair<TKey, bool>(keyValue, false);
+            if (_disposed)
+                throw new ObjectDisposedException(nameof(MappedSink<TKey>), "The mapped sink has been disposed.");
 
-            lock (_sync)
+            if (_sinkMap.TryGetValue(key, out var existing))
             {
-                if (_disposed)
-                    throw new ObjectDisposedException(nameof(MappedSink<TKey>), "The mapped sink has been disposed.");
-
-                if (_sinkMap.TryGetValue(key, out var existing))
-                {
-                    existing.Emit(logEvent);
-                    return;
-                }
+                existing.Emit(logEvent);
+                return;
+            }
 
-                var sink = CreateSink(key.Key);
+            var sink = LoggerSinkConfiguration.CreateSink(wt => _configure(key.Key, wt));
 
-                if (_sinkMapCountLimit == 0)
-                {
-                    using (sink as IDisposable)
-                        sink.Emit(logEvent);
-                }
-                else if (_sinkMapCountLimit == null || _sinkMapCountLimit > _sinkMap.Count)
+            if (_sinkMapCountLimit == 0)
+            {
+                using (sink as IDisposable)
+                    sink.Emit(logEvent);
+            }
+            else if (_sinkMapCountLimit == null || _sinkMapCountLimit > _sinkMap.Count)
+            {
+                // This case is a little faster as no EH nor iteration is required
+                _sinkMap[key] = sink;
+                sink.Emit(logEvent);
+            }
+            else
+            {
+                _sinkMap[key] = sink;
+                try
                 {
-                    // This case is a little faster as no EH nor iteration is required
-                    _sinkMap[key] = sink;
                     sink.Emit(logEvent);
                 }
-                else
+                finally
                 {
-                    _sinkMap[key] = sink;
-                    try
-                    {
-                        sink.Emit(logEvent);
-                    }
-                    finally
+                    while (_sinkMap.Count > _sinkMapCountLimit.Value)
                     {
-                        while (_sinkMap.Count > _sinkMapCountLimit.Value)
+                        foreach (var k in _sinkMap.Keys)
                         {
-                            foreach (var k in _sinkMap.Keys)
-                            {
-                                if (key.Equals(k))
-                                    continue;
+                            if (key.Equals(k))
+                                continue;
 
-                                var removed = _sinkMap[k];
-                                _sinkMap.Remove(k);
-                                (removed as IDisposable)?.Dispose();
-                                break;
-                            }
+                            var removed = _sinkMap[k];
+                            _sinkMap.Remove(k);
+                            (removed as IDisposable)?.Dispose();
+                            break;
                         }
                     }
                 }
             }
         }
+    }
 
-        ILogEventSink CreateSink(TKey key)
+    public void Dispose()
+    {
+        lock (_sync)
         {
-            // Allocates a few delegates, but avoids a lot more allocation in the `LoggerConfiguration`/`Logger` machinery.
-            ILogEventSink sink = null;
-            LoggerSinkConfiguration.Wrap(
-                new LoggerConfiguration().WriteTo,
-                s => sink = s,
-                config => _configure(key, config),
-                LevelAlias.Minimum,
-                null);
+            if (_disposed)
+                return;
 
-            return sink;
-        }
+            _disposed = true;
 
-        public void Dispose()
-        {
-            lock (_sync)
+            var values = _sinkMap.Values.ToArray();
+            _sinkMap.Clear();
+            foreach (var sink in values)
             {
-                if (_disposed)
-                    return;
-
-                _disposed = true;
-
-                var values = _sinkMap.Values.ToArray();
-                _sinkMap.Clear();
-                foreach (var sink in values)
-                {
-                    (sink as IDisposable)?.Dispose();
-                }
+                (sink as IDisposable)?.Dispose();
             }
         }
     }
-}
+}