Use non allocating ConfigureScope overload

Author: KnapSac

src/Sentry.AspNetCore/SentryMiddleware.cs

@@ -118,7 +118,7 @@ public async Task InvokeAsync(HttpContext context, RequestDelegate next)
             context.Items.TryAdd(BaggageHeaderItemKey, baggageHeader);
             context.Items.TryAdd(TransactionContextItemKey, transactionContext);
 
-            hub.ConfigureScope(scope =>
+            hub.ConfigureScope(static (scope, arg) =>
             {
                 // At the point lots of stuff from the request are not yet filled
                 // Identity for example is added later on in the pipeline
@@ -131,16 +131,16 @@ public async Task InvokeAsync(HttpContext context, RequestDelegate next)
                 // when the event fires.  Use `activeScope`, not `scope` or `hub`.
                 scope.OnEvaluating += (_, activeScope) =>
                 {
-                    SyncOptionsScope(activeScope);
-                    PopulateScope(context, activeScope);
+                    arg.middleware.SyncOptionsScope(activeScope);
+                    arg.middleware.PopulateScope(arg.context, activeScope);
                 };
-            });
+            }, (middleware: this, context));
 
             // Pre-create the Sentry Event ID and save it on the scope it so it's available throughout the pipeline,
             // even if there's no event actually being sent to Sentry.  This allows for things like a custom exception
             // handler page to access the event ID, enabling user feedback, etc.
             var eventId = SentryId.Create();
-            hub.ConfigureScope(scope => scope.LastEventId = eventId);
+            hub.ConfigureScope(static (scope, eventId) => scope.LastEventId = eventId, eventId);
 
             try
             {
@@ -167,7 +167,7 @@ public async Task InvokeAsync(HttpContext context, RequestDelegate next)
                 {
                     // 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));
+                    hub.ConfigureScope(static (scope, activity) => activity.SetFused(scope), activity);
                 }
 
                 // When an exception was handled by other component (i.e: UseExceptionHandler feature).
@@ -179,12 +179,12 @@ public async Task InvokeAsync(HttpContext context, RequestDelegate next)
                         "The web server likely returned a customized error page as a result of this exception.";
 
 #if NET6_0_OR_GREATER
-                    hub.ConfigureScope(scope =>
+                    hub.ConfigureScope(static (scope, arg) =>
                     {
                         scope.ExceptionProcessors.Add(
-                            new ExceptionHandlerFeatureProcessor(originalMethod, exceptionFeature)
+                            new ExceptionHandlerFeatureProcessor(arg.originalMethod, arg.exceptionFeature)
                             );
-                    });
+                    }, (originalMethod, exceptionFeature));
 #endif
                     CaptureException(exceptionFeature.Error, eventId, "IExceptionHandlerFeature", description);
                 }

src/Sentry.AspNetCore/SentryTracingMiddleware.cs

@@ -130,10 +130,7 @@ public async Task InvokeAsync(HttpContext context)
 
         // Expose the transaction on the scope so that the user
         // can retrieve it and start child spans off of it.
-        hub.ConfigureScope(scope =>
-        {
-            scope.Transaction = transaction;
-        });
+        hub.ConfigureScope(static (scope, transaction) => scope.Transaction = transaction, transaction);
 
         Exception? exception = null;
         try

src/Sentry.Extensions.Logging/SentryLoggerProvider.cs

@@ -48,7 +48,7 @@ internal SentryLoggerProvider(
         if (hub.IsEnabled)
         {
             _scope = hub.PushScope();
-            hub.ConfigureScope(s =>
+            hub.ConfigureScope(static s =>
             {
                 if (s.Sdk is { } sdk)
                 {

src/Sentry.OpenTelemetry/AspNetCoreEnricher.cs

@@ -10,13 +10,13 @@ public void Enrich(ISpan span, Activity activity, IHub hub, SentryOptions? optio
     {
         if (options?.SendDefaultPii is true)
         {
-            hub.ConfigureScope(scope =>
+            hub.ConfigureScope(static (scope, enricher) =>
             {
-                if (!scope.HasUser() && _userFactory.Create() is { } user)
+                if (!scope.HasUser() && enricher._userFactory.Create() is { } user)
                 {
                     scope.User = user;
                 }
-            });
+            }, this);
         }
     }
 }

src/Sentry.OpenTelemetry/SentrySpanProcessor.cs

@@ -166,7 +166,7 @@ private void CreateRootSpan(Activity data)
         );
         transaction.Contexts.Trace.Origin = OpenTelemetryOrigin;
         transaction.StartTimestamp = data.StartTimeUtc;
-        _hub.ConfigureScope(scope => scope.Transaction = transaction);
+        _hub.ConfigureScope(static (scope, transaction) => scope.Transaction = transaction, transaction);
         transaction.SetFused(data);
         _map[data.SpanId] = transaction;
     }

src/Sentry/HubExtensions.cs

@@ -56,14 +56,11 @@ public static ITransactionTracer StartTransaction(
     /// </summary>
     public static ISpan StartSpan(this IHub hub, string operation, string description)
     {
-        ITransactionTracer? currentTransaction = null;
-        hub.ConfigureScope(s => currentTransaction = s.Transaction);
-        return currentTransaction is { } transaction
+        return hub.GetTransaction() is { } transaction
             ? transaction.StartChild(operation, description)
             : hub.StartTransaction(operation, description); // this is actually in the wrong order but changing it may break other things
     }
 
-
     /// <summary>
     /// Adds a breadcrumb to the current scope.
     /// </summary>
@@ -158,8 +155,8 @@ public static void AddBreadcrumb(
         }
 
         hub.ConfigureScope(
-            s => s.AddBreadcrumb(breadcrumb, hint ?? new SentryHint())
-            );
+            static(s, arg) => s.AddBreadcrumb(arg.breadcrumb, arg.hint ?? new SentryHint()),
+            (breadcrumb, hint));
     }
 
     /// <summary>
@@ -175,13 +172,13 @@ public static void AddBreadcrumb(
     /// like Loggers which guarantee log messages are not lost.
     /// </remarks>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public static void LockScope(this IHub hub) => hub.ConfigureScope(c => c.Locked = true);
+    public static void LockScope(this IHub hub) => hub.ConfigureScope(static s => s.Locked = true);
 
     /// <summary>
     /// Unlocks the current scope to allow subsequent calls to <see cref="ISentryScopeManager.PushScope"/> create new scopes.
     /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public static void UnlockScope(this IHub hub) => hub.ConfigureScope(c => c.Locked = false);
+    public static void UnlockScope(this IHub hub) => hub.ConfigureScope(static s => s.Locked = false);
 
     private sealed class LockedScope : IDisposable
     {

src/Sentry/Internal/Hub.cs

@@ -296,7 +296,7 @@ public TransactionContext ContinueTrace(
         string? operation = null)
     {
         var propagationContext = SentryPropagationContext.CreateFromHeaders(_options.DiagnosticLogger, traceHeader, baggageHeader, _replaySession);
-        ConfigureScope(scope => scope.SetPropagationContext(propagationContext));
+        ConfigureScope(static (scope, propagationContext) => scope.SetPropagationContext(propagationContext), propagationContext);
 
         return new TransactionContext(
             name: name ?? string.Empty,

src/Sentry/Internal/UnsampledTransaction.cs

@@ -64,11 +64,11 @@ public override void Finish()
 
         // Clear the transaction from the scope and regenerate the Propagation Context, so new events don't have a
         // trace context that is "older" than the transaction that just finished
-        _hub.ConfigureScope(scope =>
+        _hub.ConfigureScope(static (scope, transactionTracer) =>
         {
-            scope.ResetTransaction(this);
+            scope.ResetTransaction(transactionTracer);
             scope.SetPropagationContext(new SentryPropagationContext());
-        });
+        }, this);
 
         // Record the discarded events
         var spanCount = Spans.Count + 1; // 1 for each span + 1 for the transaction itself

src/Sentry/TransactionTracer.cs

@@ -386,11 +386,11 @@ public void Finish()
 
         // Clear the transaction from the scope and regenerate the Propagation Context
         // We do this so new events don't have a trace context that is "older" than the transaction that just finished
-        _hub.ConfigureScope(scope =>
+        _hub.ConfigureScope(static (scope, transactionTracer) =>
         {
-            scope.ResetTransaction(this);
+            scope.ResetTransaction(transactionTracer);
             scope.SetPropagationContext(new SentryPropagationContext());
-        });
+        }, this);
 
         // Client decides whether to discard this transaction based on sampling
         _hub.CaptureTransaction(new SentryTransaction(this));