perf(core): Remove usage of addNonEnumerableProperty from span utils

Author: AbhiPrasad

packages/core/src/tracing/utils.ts

@@ -1,20 +1,14 @@
 import type { Scope } from '../scope';
 import type { Span } from '../types-hoist';
-import { addNonEnumerableProperty } from '../utils-hoist/object';
 
-const SCOPE_ON_START_SPAN_FIELD = '_sentryScope';
-const ISOLATION_SCOPE_ON_START_SPAN_FIELD = '_sentryIsolationScope';
-
-type SpanWithScopes = Span & {
-  [SCOPE_ON_START_SPAN_FIELD]?: Scope;
-  [ISOLATION_SCOPE_ON_START_SPAN_FIELD]?: Scope;
-};
+const SPAN_TO_SCOPE_MAP = new WeakMap<Span, Scope>();
+const SPAN_TO_ISOLATION_SCOPE_MAP = new WeakMap<Span, Scope>();
 
 /** 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);
+    SPAN_TO_SCOPE_MAP.set(span, scope);
+    SPAN_TO_ISOLATION_SCOPE_MAP.set(span, isolationScope);
   }
 }
 
@@ -23,7 +17,7 @@ export function setCapturedScopesOnSpan(span: Span | undefined, scope: Scope, is
  */
 export function getCapturedScopesOnSpan(span: Span): { scope?: Scope; isolationScope?: Scope } {
   return {
-    scope: (span as SpanWithScopes)[SCOPE_ON_START_SPAN_FIELD],
-    isolationScope: (span as SpanWithScopes)[ISOLATION_SCOPE_ON_START_SPAN_FIELD],
+    scope: SPAN_TO_SCOPE_MAP.get(span),
+    isolationScope: SPAN_TO_ISOLATION_SCOPE_MAP.get(span),
   };
 }

packages/core/src/utils/spanUtils.ts

@@ -21,7 +21,7 @@ import type {
 } from '../types-hoist';
 import type { SpanLink, SpanLinkJSON } from '../types-hoist/link';
 import { consoleSandbox } from '../utils-hoist/logger';
-import { addNonEnumerableProperty, dropUndefinedKeys } from '../utils-hoist/object';
+import { dropUndefinedKeys } from '../utils-hoist/object';
 import { generateSpanId } from '../utils-hoist/propagationContext';
 import { timestampInSeconds } from '../utils-hoist/time';
 import { generateSentryTraceHeader } from '../utils-hoist/tracing';
@@ -223,55 +223,54 @@ export function getStatusMessage(status: SpanStatus | undefined): string | undef
   return status.message || 'unknown_error';
 }
 
-const CHILD_SPANS_FIELD = '_sentryChildSpans';
-const ROOT_SPAN_FIELD = '_sentryRootSpan';
-
-type SpanWithPotentialChildren = Span & {
-  [CHILD_SPANS_FIELD]?: Set<Span>;
-  [ROOT_SPAN_FIELD]?: Span;
-};
+const SPAN_TO_ROOT_SPAN_MAP = new WeakMap<Span, Span>();
+const SPAN_TO_CHILD_SPANS_MAP = new WeakMap<Span, Set<Span>>();
 
 /**
  * Adds an opaque child span reference to a span.
  */
-export function addChildSpanToSpan(span: SpanWithPotentialChildren, childSpan: Span): void {
+export function addChildSpanToSpan(span: Span, childSpan: Span): void {
   // We store the root span reference on the child span
   // We need this for `getRootSpan()` to work
-  const rootSpan = span[ROOT_SPAN_FIELD] || span;
-  addNonEnumerableProperty(childSpan as SpanWithPotentialChildren, ROOT_SPAN_FIELD, rootSpan);
+  const rootSpan = SPAN_TO_ROOT_SPAN_MAP.get(span) || span;
+  SPAN_TO_ROOT_SPAN_MAP.set(childSpan, rootSpan);
 
   // We store a list of child spans on the parent span
   // We need this for `getSpanDescendants()` to work
-  if (span[CHILD_SPANS_FIELD]) {
-    span[CHILD_SPANS_FIELD].add(childSpan);
+  const childSpans = SPAN_TO_CHILD_SPANS_MAP.get(span);
+  if (childSpans) {
+    childSpans.add(childSpan);
   } else {
-    addNonEnumerableProperty(span, CHILD_SPANS_FIELD, new Set([childSpan]));
+    SPAN_TO_CHILD_SPANS_MAP.set(span, new Set([childSpan]));
   }
 }
 
 /** This is only used internally by Idle Spans. */
-export function removeChildSpanFromSpan(span: SpanWithPotentialChildren, childSpan: Span): void {
-  if (span[CHILD_SPANS_FIELD]) {
-    span[CHILD_SPANS_FIELD].delete(childSpan);
+export function removeChildSpanFromSpan(span: Span, childSpan: Span): void {
+  const childSpans = SPAN_TO_CHILD_SPANS_MAP.get(span);
+  if (childSpans) {
+    childSpans.delete(childSpan);
   }
 }
 
 /**
  * Returns an array of the given span and all of its descendants.
  */
-export function getSpanDescendants(span: SpanWithPotentialChildren): Span[] {
+export function getSpanDescendants(span: Span): Span[] {
   const resultSet = new Set<Span>();
 
-  function addSpanChildren(span: SpanWithPotentialChildren): void {
+  function addSpanChildren(span: Span): void {
     // This exit condition is required to not infinitely loop in case of a circular dependency.
     if (resultSet.has(span)) {
       return;
       // We want to ignore unsampled spans (e.g. non recording spans)
     } else if (spanIsSampled(span)) {
       resultSet.add(span);
-      const childSpans = span[CHILD_SPANS_FIELD] ? Array.from(span[CHILD_SPANS_FIELD]) : [];
-      for (const childSpan of childSpans) {
-        addSpanChildren(childSpan);
+      const childSpans = SPAN_TO_CHILD_SPANS_MAP.get(span);
+      if (childSpans) {
+        for (const childSpan of childSpans) {
+          addSpanChildren(childSpan);
+        }
       }
     }
   }
@@ -284,8 +283,8 @@ export function getSpanDescendants(span: SpanWithPotentialChildren): Span[] {
 /**
  * Returns the root span of a given span.
  */
-export function getRootSpan(span: SpanWithPotentialChildren): Span {
-  return span[ROOT_SPAN_FIELD] || span;
+export function getRootSpan(span: Span): Span {
+  return SPAN_TO_ROOT_SPAN_MAP.get(span) || span;
 }
 
 /**

packages/core/test/lib/tracing/trace.test.ts

@@ -687,7 +687,7 @@ describe('startSpan', () => {
     expect.assertions(1);
     startSpan({ name: 'outer' }, (outerSpan: any) => {
       startSpan({ name: 'inner' }, innerSpan => {
-        const childSpans = Array.from(outerSpan._sentryChildSpans);
+        const childSpans = getSpanDescendants(outerSpan);
         expect(childSpans).toContain(innerSpan);
       });
     });
@@ -1178,7 +1178,7 @@ describe('startSpanManual', () => {
     expect.assertions(1);
     startSpan({ name: 'outer' }, (outerSpan: any) => {
       startSpanManual({ name: 'inner' }, innerSpan => {
-        const childSpans = Array.from(outerSpan._sentryChildSpans);
+        const childSpans = getSpanDescendants(outerSpan);
         expect(childSpans).toContain(innerSpan);
       });
     });
@@ -1591,7 +1591,7 @@ describe('startInactiveSpan', () => {
     expect.assertions(1);
     startSpan({ name: 'outer' }, (outerSpan: any) => {
       const innerSpan = startInactiveSpan({ name: 'inner' });
-      const childSpans = Array.from(outerSpan._sentryChildSpans);
+      const childSpans = getSpanDescendants(outerSpan);
       expect(childSpans).toContain(innerSpan);
     });
   });

packages/opentelemetry/src/utils/contextData.ts

@@ -1,11 +1,8 @@
 import type { Context } from '@opentelemetry/api';
 import type { Scope } from '@sentry/core';
-import { addNonEnumerableProperty } from '@sentry/core';
 import { SENTRY_SCOPES_CONTEXT_KEY } from '../constants';
 import type { CurrentScopes } from '../types';
 
-const SCOPE_CONTEXT_FIELD = '_scopeContext';
-
 /**
  * Try to get the current scopes from the given OTEL context.
  * This requires a Context Manager that was wrapped with getWrappedContextManager.
@@ -22,17 +19,19 @@ export function setScopesOnContext(context: Context, scopes: CurrentScopes): Con
   return context.setValue(SENTRY_SCOPES_CONTEXT_KEY, scopes);
 }
 
+const SCOPE_TO_CONTEXT_MAP = new WeakMap<Scope, Context>();
+
 /**
  * Set the context on the scope so we can later look it up.
  * We need this to get the context from the scope in the `trace` functions.
  */
 export function setContextOnScope(scope: Scope, context: Context): void {
-  addNonEnumerableProperty(scope, SCOPE_CONTEXT_FIELD, context);
+  SCOPE_TO_CONTEXT_MAP.set(scope, context);
 }
 
 /**
  * Get the context related to a scope.
  */
 export function getContextFromScope(scope: Scope): Context | undefined {
-  return (scope as { [SCOPE_CONTEXT_FIELD]?: Context })[SCOPE_CONTEXT_FIELD];
+  return SCOPE_TO_CONTEXT_MAP.get(scope);
 }