Fix: Scope not being applied to OpenTelemetry spans in ASP.NET Core

CHANGELOG.md

@@ -11,6 +11,9 @@
 
 - Release of Azure Functions (Isolated Worker/Out-of-Process) support ([#2686](https://github.com/getsentry/sentry-dotnet/pull/2686))
 
+### Fixes
+- Scope is now correctly applied to Transactions when using OpenTelemetry on ASP.NET Core ([#2690](https://github.com/getsentry/sentry-dotnet/pull/2690))
+
 ### Dependencies
 
 - Bump CLI from v2.20.7 to v2.21.1 ([#2645](https://github.com/getsentry/sentry-dotnet/pull/2645), [#2647](https://github.com/getsentry/sentry-dotnet/pull/2647))

src/Sentry.AspNetCore/SentryMiddleware.cs

@@ -9,6 +9,7 @@
 using Microsoft.Extensions.Options;
 using Sentry.AspNetCore.Extensions;
 using Sentry.Extensibility;
+using Sentry.Internal;
 using Sentry.Reflection;
 
 namespace Sentry.AspNetCore;
@@ -132,6 +133,12 @@ public async Task InvokeAsync(HttpContext context, RequestDelegate next)
             {
                 var originalMethod = context.Request.Method;
                 await next(context).ConfigureAwait(false);
+                if (_options.Instrumenter == Instrumenter.OpenTelemetry && Activity.Current is {} activity)
+                {
+                    // The middleware pipeline finishes up before the Otel Activity.OnEnd callback is invoked so we need
+                    // so save a copy of the scope that can be restored by our SentrySpanProcessor
+                    hub.ConfigureScope(scope => activity.SetFused(scope.Clone()));
+                }
 
                 // When an exception was handled by other component (i.e: UseExceptionHandler feature).
                 var exceptionFeature = context.Features.Get<IExceptionHandlerFeature?>();

src/Sentry.OpenTelemetry/SentrySpanProcessor.cs

@@ -1,5 +1,6 @@
 using OpenTelemetry;
 using Sentry.Extensibility;
+using Sentry.Internal;
 using Sentry.Internal.Extensions;
 using Sentry.Internal.OpenTelemetry;
 
@@ -156,6 +157,12 @@ public override void OnEnd(Activity data)
 
             // Transactions set otel attributes (and resource attributes) as context.
             transaction.Contexts["otel"] = GetOtelContext(attributes);
+
+            var activityScope = data.GetFused<Scope>();
+            if (activityScope is { } savedScope && _hub is IHubEx hub)
+            {
+                hub.RestoreScope(savedScope);
+            }
         }
         else
         {

src/Sentry/Extensibility/HubAdapter.cs

@@ -210,6 +210,11 @@ public void AddBreadcrumb(
     SentryId IHubEx.CaptureEventInternal(SentryEvent evt, Hint? hint, Scope? scope)
         => SentrySdk.CaptureEventInternal(evt, hint, scope);
 
+    /// <summary>
+    /// Forwards the call to <see cref="SentrySdk"/>
+    /// </summary>
+    public void RestoreScope(Scope savedScope) => SentrySdk.RestoreScope(savedScope);
+
     /// <summary>
     /// Forwards the call to <see cref="SentrySdk"/>.
     /// </summary>

src/Sentry/Internal/Hub.cs

@@ -1,6 +1,7 @@
 using Sentry.Extensibility;
 using Sentry.Infrastructure;
 using Sentry.Integrations;
+using Sentry.Internal.ScopeStack;
 
 namespace Sentry.Internal;
 
@@ -97,6 +98,8 @@ public async Task ConfigureScopeAsync(Func<Scope, Task> configureScope)
 
     public IDisposable PushScope<TState>(TState state) => ScopeManager.PushScope(state);
 
+    public void RestoreScope(Scope savedScope) => ScopeManager.RestoreScope(savedScope);
+
     [Obsolete]
     public void WithScope(Action<Scope> scopeCallback) => ScopeManager.WithScope(scopeCallback);
 
@@ -486,8 +489,7 @@ public void CaptureTransaction(Transaction transaction, Hint? hint)
         try
         {
             // Apply scope data
-            var currentScopeAndClient = ScopeManager.GetCurrent();
-            var scope = currentScopeAndClient.Key;
+            var (scope, client) = ScopeManager.GetCurrent();
             scope.Evaluate();
             scope.Apply(transaction);
 
@@ -513,7 +515,6 @@ public void CaptureTransaction(Transaction transaction, Hint? hint)
                 }
             }
 
-            var client = currentScopeAndClient.Value;
             client.CaptureTransaction(processedTransaction, hint);
         }
         catch (Exception e)
@@ -543,8 +544,8 @@ public async Task FlushAsync(TimeSpan timeout)
     {
         try
         {
-            var currentScope = ScopeManager.GetCurrent();
-            await currentScope.Value.FlushAsync(timeout).ConfigureAwait(false);
+            var (_, client) = ScopeManager.GetCurrent();
+            await client.FlushAsync(timeout).ConfigureAwait(false);
         }
         catch (Exception e)
         {

src/Sentry/Internal/IHubEx.cs

@@ -3,6 +3,8 @@ namespace Sentry.Internal;
 internal interface IHubEx : IHub
 {
     SentryId CaptureEventInternal(SentryEvent evt, Hint? hint, Scope? scope = null);
+    void RestoreScope(Scope savedScope);
+
     T? WithScope<T>(Func<Scope, T?> scopeCallback);
     Task WithScopeAsync(Func<Scope, Task> scopeCallback);
     Task<T?> WithScopeAsync<T>(Func<Scope, Task<T?>> scopeCallback);

src/Sentry/Internal/IInternalScopeManager.cs

@@ -5,6 +5,8 @@ namespace Sentry.Internal;
 internal interface IInternalScopeManager : ISentryScopeManager, IDisposable
 {
     KeyValuePair<Scope, ISentryClient> GetCurrent();
+    void RestoreScope(Scope savedScope);
+
     IScopeStackContainer ScopeStackContainer { get; }
 
     // TODO: Move The following to ISentryScopeManager in a future major version.

src/Sentry/Internal/SentryScopeManager.cs

@@ -30,22 +30,18 @@ public SentryScopeManager(SentryOptions options, ISentryClient rootClient)
         NewStack = () => new[] { new KeyValuePair<Scope, ISentryClient>(new Scope(options), rootClient) };
     }
 
-    public KeyValuePair<Scope, ISentryClient> GetCurrent()
-    {
-        var current = ScopeAndClientStack;
-        return current[^1];
-    }
+    public KeyValuePair<Scope, ISentryClient> GetCurrent() => ScopeAndClientStack[^1];
 
     public void ConfigureScope(Action<Scope>? configureScope)
     {
-        var scope = GetCurrent();
-        configureScope?.Invoke(scope.Key);
+        var (scope, _) = GetCurrent();
+        configureScope?.Invoke(scope);
     }
 
     public Task ConfigureScopeAsync(Func<Scope, Task>? configureScope)
     {
-        var scope = GetCurrent();
-        return configureScope?.Invoke(scope.Key) ?? Task.CompletedTask;
+        var (scope, _) = GetCurrent();
+        return configureScope?.Invoke(scope) ?? Task.CompletedTask;
     }
 
     public IDisposable PushScope() => PushScope<object>(null);
@@ -91,40 +87,52 @@ public IDisposable PushScope<TState>(TState? state)
         ScopeAndClientStack = newScopeAndClientStack;
         return scopeSnapshot;
     }
+    public void RestoreScope(Scope savedScope)
+    {
+        var currentScopeAndClientStack = ScopeAndClientStack;
+        var (previousScope, client) = currentScopeAndClientStack[^1];
+
+        _options.LogDebug("Scope restored");
+        var newScopeAndClientStack = new KeyValuePair<Scope, ISentryClient>[currentScopeAndClientStack.Length + 1];
+        Array.Copy(currentScopeAndClientStack, newScopeAndClientStack, currentScopeAndClientStack.Length);
+        newScopeAndClientStack[^1] = new KeyValuePair<Scope, ISentryClient>(savedScope, client);
+
+        ScopeAndClientStack = newScopeAndClientStack;
+    }
 
     public void WithScope(Action<Scope> scopeCallback)
     {
         using (PushScope())
         {
-            var scope = GetCurrent();
-            scopeCallback.Invoke(scope.Key);
+            var (scope, _) = GetCurrent();
+            scopeCallback.Invoke(scope);
         }
     }
 
     public T? WithScope<T>(Func<Scope, T?> scopeCallback)
     {
         using (PushScope())
         {
-            var scope = GetCurrent();
-            return scopeCallback.Invoke(scope.Key);
+            var (scope, _) = GetCurrent();
+            return scopeCallback.Invoke(scope);
         }
     }
 
     public async Task WithScopeAsync(Func<Scope, Task> scopeCallback)
     {
         using (PushScope())
         {
-            var scope = GetCurrent();
-            await scopeCallback.Invoke(scope.Key).ConfigureAwait(false);
+            var (scope, _) = GetCurrent();
+            await scopeCallback.Invoke(scope).ConfigureAwait(false);
         }
     }
 
     public async Task<T?> WithScopeAsync<T>(Func<Scope, Task<T?>> scopeCallback)
     {
         using (PushScope())
         {
-            var scope = GetCurrent();
-            return await scopeCallback.Invoke(scope.Key).ConfigureAwait(false);
+            var (scope, _) = GetCurrent();
+            return await scopeCallback.Invoke(scope).ConfigureAwait(false);
         }
     }
 

src/Sentry/SentrySdk.cs

@@ -240,6 +240,17 @@ public void Dispose()
     [DebuggerStepThrough]
     public static IDisposable PushScope<TState>(TState state) => CurrentHub.PushScope(state);
 
+    /// <summary>
+    /// Restores a previously saved/cloned scope to the top of the stack
+    /// </summary>
+    public static void RestoreScope(Scope savedScope)
+    {
+        if (CurrentHub is IHubEx hub)
+        {
+            hub.RestoreScope(savedScope);
+        }
+    }
+
     /// <summary>
     /// Creates a new scope that will terminate when disposed.
     /// </summary>

src/Sentry/TransactionTracer.cs

@@ -1,5 +1,6 @@
 using Sentry.Extensibility;
 using Sentry.Internal;
+using Sentry.Internal.ScopeStack;
 using Sentry.Protocol;
 
 namespace Sentry;

test/Sentry.Tests/ApiApprovalTests.Run.Core3_1.verified.txt

@@ -779,6 +779,7 @@ namespace Sentry
         public static void PauseSession() { }
         public static System.IDisposable PushScope() { }
         public static System.IDisposable PushScope<TState>(TState state) { }
+        public static void RestoreScope(Sentry.Scope savedScope) { }
         public static void ResumeSession() { }
         public static void StartSession() { }
         public static Sentry.ITransaction StartTransaction(Sentry.ITransactionContext context) { }
@@ -1301,6 +1302,7 @@ namespace Sentry.Extensibility
         public void PauseSession() { }
         public System.IDisposable PushScope() { }
         public System.IDisposable PushScope<TState>(TState state) { }
+        public void RestoreScope(Sentry.Scope savedScope) { }
         public void ResumeSession() { }
         public void StartSession() { }
         public Sentry.ITransaction StartTransaction(Sentry.ITransactionContext context, System.Collections.Generic.IReadOnlyDictionary<string, object?> customSamplingContext) { }

test/Sentry.Tests/ApiApprovalTests.Run.DotNet6_0.verified.txt

@@ -780,6 +780,7 @@ namespace Sentry
         public static void PauseSession() { }
         public static System.IDisposable PushScope() { }
         public static System.IDisposable PushScope<TState>(TState state) { }
+        public static void RestoreScope(Sentry.Scope savedScope) { }
         public static void ResumeSession() { }
         public static void StartSession() { }
         public static Sentry.ITransaction StartTransaction(Sentry.ITransactionContext context) { }
@@ -1302,6 +1303,7 @@ namespace Sentry.Extensibility
         public void PauseSession() { }
         public System.IDisposable PushScope() { }
         public System.IDisposable PushScope<TState>(TState state) { }
+        public void RestoreScope(Sentry.Scope savedScope) { }
         public void ResumeSession() { }
         public void StartSession() { }
         public Sentry.ITransaction StartTransaction(Sentry.ITransactionContext context, System.Collections.Generic.IReadOnlyDictionary<string, object?> customSamplingContext) { }

test/Sentry.Tests/ApiApprovalTests.Run.DotNet7_0.verified.txt

@@ -780,6 +780,7 @@ namespace Sentry
         public static void PauseSession() { }
         public static System.IDisposable PushScope() { }
         public static System.IDisposable PushScope<TState>(TState state) { }
+        public static void RestoreScope(Sentry.Scope savedScope) { }
         public static void ResumeSession() { }
         public static void StartSession() { }
         public static Sentry.ITransaction StartTransaction(Sentry.ITransactionContext context) { }
@@ -1302,6 +1303,7 @@ namespace Sentry.Extensibility
         public void PauseSession() { }
         public System.IDisposable PushScope() { }
         public System.IDisposable PushScope<TState>(TState state) { }
+        public void RestoreScope(Sentry.Scope savedScope) { }
         public void ResumeSession() { }
         public void StartSession() { }
         public Sentry.ITransaction StartTransaction(Sentry.ITransactionContext context, System.Collections.Generic.IReadOnlyDictionary<string, object?> customSamplingContext) { }

test/Sentry.Tests/ApiApprovalTests.Run.Net4_8.verified.txt

@@ -778,6 +778,7 @@ namespace Sentry
         public static void PauseSession() { }
         public static System.IDisposable PushScope() { }
         public static System.IDisposable PushScope<TState>(TState state) { }
+        public static void RestoreScope(Sentry.Scope savedScope) { }
         public static void ResumeSession() { }
         public static void StartSession() { }
         public static Sentry.ITransaction StartTransaction(Sentry.ITransactionContext context) { }
@@ -1300,6 +1301,7 @@ namespace Sentry.Extensibility
         public void PauseSession() { }
         public System.IDisposable PushScope() { }
         public System.IDisposable PushScope<TState>(TState state) { }
+        public void RestoreScope(Sentry.Scope savedScope) { }
         public void ResumeSession() { }
         public void StartSession() { }
         public Sentry.ITransaction StartTransaction(Sentry.ITransactionContext context, System.Collections.Generic.IReadOnlyDictionary<string, object?> customSamplingContext) { }