Added a SerilogScopeEventProcessor to sync Serilog scope properties to Sentry events

Author: jamescrosswell

src/Sentry.Serilog/SentryOptionExtensions.cs

@@ -0,0 +1,21 @@
+namespace Sentry.Serilog;
+
+/// <summary>
+/// Extensions for <see cref="SentryOptions"/> to add Serilog specific configuration.
+/// </summary>
+public static class SentryOptionExtensions
+{
+    /// <summary>
+    /// Ensures Serilog scope properties get applied to Sentry events. If you are not initialising Sentry when
+    /// configuring the Sentry sink for Serilog then you should call this method in the options callback for whichever
+    /// Sentry integration you are using to initialise Sentry.
+    /// </summary>
+    /// <param name="options"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    public static T ApplySerilogScopeToEvents<T>(this T options) where T : SentryOptions
+    {
+        options.AddEventProcessor(new SerilogScopeEventProcessor(options));
+        return options;
+    }
+}

src/Sentry.Serilog/SentrySinkExtensions.cs

@@ -326,6 +326,14 @@ internal static void ConfigureSentrySerilogOptions(
                 sentrySerilogOptions.DefaultTags.Add(tag.Key, tag.Value);
             }
         }
+
+        // This only works when the SDK is initialized using the LoggerSinkConfiguration extensions. If the SDK is
+        // initialized using some other integration then the processor will need to be added manually to whichever
+        // options are used to initialize the SDK.
+        if (sentrySerilogOptions.InitializeSdk)
+        {
+            sentrySerilogOptions.ApplySerilogScopeToEvents();
+        }
     }
 
     /// <summary>

src/Sentry.Serilog/SerilogScopeEventProcessor.cs

@@ -0,0 +1,52 @@
+using Serilog.Context;
+
+namespace Sentry.Serilog;
+
+/// <summary>
+/// Sentry event processor that applies properties from the Serilog scope to Sentry events.
+/// </summary>
+internal class SerilogScopeEventProcessor : ISentryEventProcessor
+{
+    private readonly SentryOptions _options;
+
+    /// <summary>
+    /// This processor extracts properties from the Serilog context and applies these to Sentry events.
+    /// </summary>
+    public SerilogScopeEventProcessor(SentryOptions options)
+    {
+        _options = options;
+        _options.LogDebug("Initializing Serilog scope event processor.");
+    }
+
+    /// <inheritdoc cref="ISentryEventProcessor"/>
+    public SentryEvent Process(SentryEvent @event)
+    {
+        _options.LogDebug("Running Serilog scope event processor on: Event {0}", @event.EventId);
+
+        // This is a bit of a hack. Serilog doesn't have any hooks that let us inspect the context. We can, however,
+        // apply the context to a dummy log event and then copy across the properties from that log event to our Sentry
+        // event.
+        // See: https://github.com/getsentry/sentry-dotnet/issues/3544#issuecomment-2307884977
+        var enricher = LogContext.Clone();
+        var logEvent = new LogEvent(DateTimeOffset.Now, LogEventLevel.Error, null, MessageTemplate.Empty, []);
+        enricher.Enrich(logEvent, new LogEventPropertyFactory());
+        foreach (var (key, value) in logEvent.Properties)
+        {
+            if (!@event.Tags.ContainsKey(key))
+            {
+                // Potentially we could be doing SetData here instead of SetTag. See DefaultSentryScopeStateProcessor.
+                @event.SetTag(key, value.ToString());
+            }
+        }
+        return @event;
+    }
+
+    private class LogEventPropertyFactory : ILogEventPropertyFactory
+    {
+        public LogEventProperty CreateProperty(string name, object? value, bool destructureObjects = false)
+        {
+            var scalarValue = new ScalarValue(value);
+            return new LogEventProperty(name, scalarValue);
+        }
+    }
+}