further fix isolation scopes

Author: mydea

packages/core/src/tracing/index.ts

@@ -22,6 +22,7 @@ export {
   startActiveSpan,
   startSpanManual,
   continueTrace,
+  setCapturedScopesOnSpan,
 } from './trace';
 export { getDynamicSamplingContextFromClient, getDynamicSamplingContextFromSpan } from './dynamicSamplingContext';
 export { setMeasurement } from './measurement';

packages/core/src/tracing/trace.ts

@@ -399,7 +399,8 @@ type SpanWithScopes = Span & {
   [ISOLATION_SCOPE_ON_START_SPAN_FIELD]?: Scope;
 };
 
-function setCapturedScopesOnSpan(span: Span | undefined, scope: Scope, isolationScope: Scope): void {
+/** Store the scope & isolation scope for a span, which can the be used when it is finished. */
+export function setCapturedScopesOnSpan(span: Span | undefined, scope: Scope, isolationScope: Scope): void {
   if (span) {
     addNonEnumerableProperty(span, ISOLATION_SCOPE_ON_START_SPAN_FIELD, isolationScope);
     addNonEnumerableProperty(span, SCOPE_ON_START_SPAN_FIELD, scope);

packages/opentelemetry/src/index.ts

@@ -12,7 +12,7 @@ export {
   getSpanParent,
   getSpanScope,
   setSpanMetadata,
-  getSpanFinishScope,
+  getSpanFinishScopes,
 } from './utils/spanData';
 
 export { getPropagationContextFromContext, setPropagationContextOnContext, setHubOnContext } from './utils/contextData';

packages/opentelemetry/src/spanExporter.ts

@@ -3,7 +3,14 @@ import type { ExportResult } from '@opentelemetry/core';
 import { ExportResultCode } from '@opentelemetry/core';
 import type { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
 import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
-import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, flush, getCurrentHub, getCurrentScope } from '@sentry/core';
+import {
+  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
+  flush,
+  getCurrentHub,
+  getCurrentScope,
+  getIsolationScope,
+  setCapturedScopesOnSpan,
+} from '@sentry/core';
 import type { Scope, Span as SentrySpan, SpanOrigin, TransactionSource } from '@sentry/types';
 import { logger } from '@sentry/utils';
 
@@ -17,7 +24,7 @@ import type { SpanNode } from './utils/groupSpansWithParents';
 import { groupSpansWithParents } from './utils/groupSpansWithParents';
 import { mapStatus } from './utils/mapStatus';
 import { parseSpanDescription } from './utils/parseSpanDescription';
-import { getSpanFinishScope, getSpanHub, getSpanMetadata, getSpanScope } from './utils/spanData';
+import { getSpanFinishScopes, getSpanHub, getSpanMetadata, getSpanScope } from './utils/spanData';
 
 type SpanNodeCompleted = SpanNode & { span: ReadableSpan };
 
@@ -109,24 +116,30 @@ function maybeSend(spans: ReadableSpan[]): ReadableSpan[] {
 
     // Now finish the transaction, which will send it together with all the spans
     // We make sure to use the finish scope
-    const scope = getScopeForTransactionFinish(span);
-    transaction.finishWithScope(convertOtelTimeToSeconds(span.endTime), scope);
+    const { scope, isolationScope } = getScopesForTransactionFinish(span);
+    setCapturedScopesOnSpan(transaction, scope, isolationScope);
+
+    transaction.end(span.endTime);
   });
 
   return Array.from(remaining)
     .map(node => node.span)
     .filter((span): span is ReadableSpan => !!span);
 }
 
-function getScopeForTransactionFinish(span: ReadableSpan): Scope {
+function getScopesForTransactionFinish(span: ReadableSpan): { scope: Scope; isolationScope: Scope } {
   // The finish scope should normally always be there (and it is already a clone),
   // but for the sake of type safety we fall back to a clone of the current scope
-  const scope = getSpanFinishScope(span) || getCurrentScope().clone();
+  const scopes = getSpanFinishScopes(span);
+  const scope = scopes?.scope || getCurrentScope().clone();
+  const isolationScope = scopes?.isolationScope || getIsolationScope();
+
   scope.setContext('otel', {
     attributes: removeSentryAttributes(span.attributes),
     resource: span.resource.attributes,
   });
-  return scope;
+
+  return { scope, isolationScope };
 }
 
 function getCompletedRootNodes(nodes: SpanNode[]): SpanNodeCompleted[] {

packages/opentelemetry/src/spanProcessor.ts

@@ -10,7 +10,7 @@ import { DEBUG_BUILD } from './debug-build';
 import { SentrySpanExporter } from './spanExporter';
 import { maybeCaptureExceptionForTimedEvent } from './utils/captureExceptionForTimedEvent';
 import { getHubFromContext } from './utils/contextData';
-import { getSpanHub, setSpanFinishScope, setSpanHub, setSpanParent, setSpanScope } from './utils/spanData';
+import { getSpanHub, setSpanFinishScopes, setSpanHub, setSpanParent, setSpanScope } from './utils/spanData';
 
 function onSpanStart(span: Span, parentContext: Context, _ScopeClass: typeof OpenTelemetryScope): void {
   // This is a reliable way to get the parent span - because this is exactly how the parent is identified in the OTEL SDK
@@ -34,13 +34,16 @@ function onSpanStart(span: Span, parentContext: Context, _ScopeClass: typeof Ope
   if (actualHub) {
     // eslint-disable-next-line deprecation/deprecation
     const scope = actualHub.getScope();
+    // eslint-disable-next-line deprecation/deprecation
+    const isolationScope = actualHub.getIsolationScope();
     setSpanScope(span, scope);
     setSpanHub(span, actualHub);
 
     // Use this scope for finishing the span
     const finishScope = (scope as OpenTelemetryScope).clone();
+    // this is needed for breadcrumbs, for now, as they are stored on the span currently
     finishScope.activeSpan = span;
-    setSpanFinishScope(span, finishScope);
+    setSpanFinishScopes(span, { scope: finishScope, isolationScope });
   }
 }
 

packages/opentelemetry/src/utils/spanData.ts

@@ -7,7 +7,13 @@ import type { AbstractSpan } from '../types';
 // This way we can enhance the data that an OTEL Span natively gives us
 // and since we are using weakmaps, we do not need to clean up after ourselves
 const SpanScope = new WeakMap<AbstractSpan, Scope>();
-const SpanFinishScope = new WeakMap<AbstractSpan, Scope>();
+const SpanFinishScopes = new WeakMap<
+  AbstractSpan,
+  {
+    scope: Scope;
+    isolationScope: Scope;
+  }
+>();
 const SpanHub = new WeakMap<AbstractSpan, Hub>();
 const SpanParent = new WeakMap<AbstractSpan, Span>();
 const SpanMetadata = new WeakMap<AbstractSpan, Partial<TransactionMetadata>>();
@@ -53,11 +59,22 @@ export function getSpanMetadata(span: AbstractSpan): Partial<TransactionMetadata
 }
 
 /** Set the Sentry scope to be used for finishing a given OTEL span. */
-export function setSpanFinishScope(span: AbstractSpan, scope: Scope): void {
-  SpanFinishScope.set(span, scope);
+export function setSpanFinishScopes(
+  span: AbstractSpan,
+  scopes: {
+    scope: Scope;
+    isolationScope: Scope;
+  },
+): void {
+  SpanFinishScopes.set(span, scopes);
 }
 
 /** Get the Sentry scope to use for finishing an OTEL span. */
-export function getSpanFinishScope(span: AbstractSpan): Scope | undefined {
-  return SpanFinishScope.get(span);
+export function getSpanFinishScopes(span: AbstractSpan):
+  | {
+      scope: Scope;
+      isolationScope: Scope;
+    }
+  | undefined {
+  return SpanFinishScopes.get(span);
 }