feat(opentelemetry): Merge node-experimental changes into opentelemetry (#10689)

This PR moves the formerly experimental stuff that we did in
node-experimental into the opentelemetry package.
This means that the generic OTEL stuff is there and can in theory also
be used with otel-browser (if a user would want that), and our node
package will eventually be built on top of that.

Mostly, this means we can delete a bunch of code!

Author: mydea

packages/node-experimental/src/index.ts

@@ -16,14 +16,8 @@ export { getAutoPerformanceIntegrations } from './integrations/getAutoPerformanc
 export * as Handlers from './sdk/handlers';
 export type { Span } from './types';
 
-export { startSpan, startSpanManual, startInactiveSpan, getActiveSpan } from '@sentry/opentelemetry';
-export {
-  getClient,
-  captureException,
-  captureEvent,
-  captureMessage,
-  withActiveSpan,
-} from './sdk/api';
+export { startSpan, startSpanManual, startInactiveSpan, getActiveSpan, withActiveSpan } from '@sentry/opentelemetry';
+export { getClient } from './sdk/api';
 // eslint-disable-next-line deprecation/deprecation
 export { getCurrentHub } from './sdk/hub';
 
@@ -86,6 +80,9 @@ export {
   getIsolationScope,
   withScope,
   withIsolationScope,
+  captureException,
+  captureEvent,
+  captureMessage,
 } from '@sentry/node';
 
 export type {

packages/node-experimental/src/otel/asyncContextStrategy.ts

@@ -1,18 +1,5 @@
-import type { Context } from '@opentelemetry/api';
 import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
-import { getCurrentScope, getIsolationScope } from '@sentry/core';
-import { setHubOnContext } from '@sentry/opentelemetry';
-import type { Scope } from '@sentry/types';
-import { getCurrentHub } from '../sdk/hub';
-
-import type { CurrentScopes } from './../sdk/types';
-import {
-  SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY,
-  SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY,
-  SENTRY_FORK_SET_SCOPE_CONTEXT_KEY,
-  getScopesFromContext,
-  setScopesOnContext,
-} from './../utils/contextData';
+import { wrapContextManagerClass } from '@sentry/opentelemetry';
 
 /**
  * This is a custom ContextManager for OpenTelemetry, which extends the default AsyncLocalStorageContextManager.
@@ -21,46 +8,4 @@ import {
  * Note that we currently only support AsyncHooks with this,
  * but since this should work for Node 14+ anyhow that should be good enough.
  */
-export class SentryContextManager extends AsyncLocalStorageContextManager {
-  /**
-   * Overwrite with() of the original AsyncLocalStorageContextManager
-   * to ensure we also create a new hub per context.
-   */
-  public with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(
-    context: Context,
-    fn: F,
-    thisArg?: ThisParameterType<F>,
-    ...args: A
-  ): ReturnType<F> {
-    const currentScopes = getScopesFromContext(context);
-    const currentScope = currentScopes?.scope || getCurrentScope();
-    const currentIsolationScope = currentScopes?.isolationScope || getIsolationScope();
-
-    const shouldForkIsolationScope = context.getValue(SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY) === true;
-    const scope = context.getValue(SENTRY_FORK_SET_SCOPE_CONTEXT_KEY) as Scope | undefined;
-    const isolationScope = context.getValue(SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY) as Scope | undefined;
-
-    const newCurrentScope = scope || currentScope.clone();
-    const newIsolationScope =
-      isolationScope || (shouldForkIsolationScope ? currentIsolationScope.clone() : currentIsolationScope);
-    const scopes: CurrentScopes = { scope: newCurrentScope, isolationScope: newIsolationScope };
-
-    const mockHub = {
-      // eslint-disable-next-line deprecation/deprecation
-      ...getCurrentHub(),
-      getScope: () => newCurrentScope,
-      getIsolationScope: () => newIsolationScope,
-    };
-
-    const ctx1 = setHubOnContext(context, mockHub);
-    const ctx2 = setScopesOnContext(ctx1, scopes);
-
-    // Remove the unneeded values again
-    const ctx3 = ctx2
-      .deleteValue(SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY)
-      .deleteValue(SENTRY_FORK_SET_SCOPE_CONTEXT_KEY)
-      .deleteValue(SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY);
-
-    return super.with(ctx3, fn, thisArg, ...args);
-  }
-}
+export const SentryContextManager = wrapContextManagerClass(AsyncLocalStorageContextManager);

packages/node-experimental/src/otel/contextManager.ts

@@ -1,12 +1,7 @@
 // PUBLIC APIS
 
-import type { Span } from '@opentelemetry/api';
-import { context, trace } from '@opentelemetry/api';
 import { getCurrentScope } from '@sentry/core';
-import type { CaptureContext, Client, Event, EventHint, Scope, SeverityLevel } from '@sentry/types';
-
-import type { ExclusiveEventHintOrCaptureContext } from '../utils/prepareEvent';
-import { parseEventHintOrCaptureContext } from '../utils/prepareEvent';
+import type { Client } from '@sentry/types';
 
 /** Get the currently active client. */
 export function getClient<C extends Client>(): C {
@@ -20,35 +15,3 @@ export function getClient<C extends Client>(): C {
   // TODO otherwise ensure we use a noop client
   return {} as C;
 }
-
-/**
- * Forks the current scope and sets the provided span as active span in the context of the provided callback.
- *
- * @param span Spans started in the context of the provided callback will be children of this span.
- * @param callback Execution context in which the provided span will be active. Is passed the newly forked scope.
- * @returns the value returned from the provided callback function.
- */
-export function withActiveSpan<T>(span: Span, callback: (scope: Scope) => T): T {
-  const newContextWithActiveSpan = trace.setSpan(context.active(), span);
-  return context.with(newContextWithActiveSpan, () => callback(getCurrentScope()));
-}
-
-/** Record an exception and send it to Sentry. */
-export function captureException(exception: unknown, hint?: ExclusiveEventHintOrCaptureContext): string {
-  return getCurrentScope().captureException(exception, parseEventHintOrCaptureContext(hint));
-}
-
-/** Record a message and send it to Sentry. */
-export function captureMessage(message: string, captureContext?: CaptureContext | SeverityLevel): string {
-  // This is necessary to provide explicit scopes upgrade, without changing the original
-  // arity of the `captureMessage(message, level)` method.
-  const level = typeof captureContext === 'string' ? captureContext : undefined;
-  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;
-
-  return getCurrentScope().captureMessage(message, level, context);
-}
-
-/** Capture a generic event and send it to Sentry. */
-export function captureEvent(event: Event, hint?: EventHint): string {
-  return getCurrentScope().captureEvent(event, hint);
-}

packages/node-experimental/src/sdk/api.ts

@@ -12,6 +12,7 @@ import type {
 
 import {
   addBreadcrumb,
+  captureEvent,
   endSession,
   getCurrentScope,
   getIsolationScope,
@@ -24,7 +25,7 @@ import {
   startSession,
   withScope,
 } from '@sentry/core';
-import { captureEvent, getClient } from './api';
+import { getClient } from './api';
 import { callExtensionMethod } from './globals';
 
 /**

packages/node-experimental/src/sdk/hub.ts

@@ -13,6 +13,7 @@ import {
   makeNodeTransport,
   spotlightIntegration,
 } from '@sentry/node';
+import { setOpenTelemetryContextAsyncContextStrategy } from '@sentry/opentelemetry';
 import type { Client, Integration, Options } from '@sentry/types';
 import {
   consoleSandbox,
@@ -26,7 +27,6 @@ import { DEBUG_BUILD } from '../debug-build';
 import { getAutoPerformanceIntegrations } from '../integrations/getAutoPerformanceIntegrations';
 import { httpIntegration } from '../integrations/http';
 import { nativeNodeFetchIntegration } from '../integrations/node-fetch';
-import { setOpenTelemetryContextAsyncContextStrategy } from '../otel/asyncContextStrategy';
 import type { NodeExperimentalClientOptions, NodeExperimentalOptions } from '../types';
 import { NodeExperimentalClient } from './client';
 import { initOtel } from './initOtel';

packages/node-experimental/src/sdk/init.ts

@@ -3,14 +3,13 @@ import { Resource } from '@opentelemetry/resources';
 import { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
 import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 import { SDK_VERSION } from '@sentry/core';
-import { SentryPropagator, SentrySampler, setupEventContextTrace } from '@sentry/opentelemetry';
+import { SentryPropagator, SentrySampler, SentrySpanProcessor, setupEventContextTrace } from '@sentry/opentelemetry';
 import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { SentryContextManager } from '../otel/contextManager';
 import type { NodeExperimentalClient } from '../types';
 import { getClient } from './api';
-import { NodeExperimentalSentrySpanProcessor } from './spanProcessor';
 
 /**
  * Initialize OpenTelemetry for Node.
@@ -55,7 +54,7 @@ export function setupOtel(client: NodeExperimentalClient): BasicTracerProvider {
     }),
     forceFlushTimeoutMillis: 500,
   });
-  provider.addSpanProcessor(new NodeExperimentalSentrySpanProcessor());
+  provider.addSpanProcessor(new SentrySpanProcessor());
 
   // Initialize the provider
   provider.register({

packages/node-experimental/src/sdk/initOtel.ts

@@ -1,6 +1,6 @@
 import { context } from '@opentelemetry/api';
+import { getScopesFromContext } from '@sentry/opentelemetry';
 import type { Scope } from '@sentry/types';
-import { getScopesFromContext } from '../utils/contextData';
 
 /**
  * Update the active isolation scope.