fix(node): Ensure late init works with all integrations (#16016)

In cases where we tweak the options we pass to the instrumentation, our
code did not handle this very well. This could lead to certain options
missing when init is called again later, as we updated the config with
incomplete/wrong options.

To fix this properly, I added a new variant to `generateInstrumentOnce`
which accepts a class and an options transformer, which ensures that the
options are always correctly transformed, no matter if called the first
or second time.

(The code to make this overloaded `generateInstrumentOnce` function work
with TS was pretty tricky, but I think it is good now - type inferral
etc. works nicely now!)

Fixes #16004

Author: mydea

packages/aws-serverless/src/integration/awslambda.ts

@@ -15,22 +15,19 @@ interface AwsLambdaOptions {
   disableAwsContextPropagation?: boolean;
 }
 
-export const instrumentAwsLambda = generateInstrumentOnce<AwsLambdaOptions>(
+export const instrumentAwsLambda = generateInstrumentOnce(
   'AwsLambda',
-  (_options: AwsLambdaOptions = {}) => {
-    const options = {
+  AwsLambdaInstrumentation,
+  (options: AwsLambdaOptions) => {
+    return {
       disableAwsContextPropagation: true,
-      ..._options,
-    };
-
-    return new AwsLambdaInstrumentation({
       ...options,
       eventContextExtractor,
       requestHook(span) {
         span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.otel.aws-lambda');
         span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'function.aws.lambda');
       },
-    });
+    };
   },
 );
 

packages/node/src/integrations/node-fetch/index.ts

@@ -5,7 +5,6 @@ import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, defineIntegration, getClient } from '
 import { generateInstrumentOnce } from '../../otel/instrument';
 import type { NodeClient } from '../../sdk/client';
 import type { NodeClientOptions } from '../../types';
-import type { SentryNodeFetchInstrumentationOptions } from './SentryNodeFetchInstrumentation';
 import { SentryNodeFetchInstrumentation } from './SentryNodeFetchInstrumentation';
 
 const INTEGRATION_NAME = 'NodeFetch';
@@ -33,14 +32,19 @@ interface NodeFetchOptions {
   ignoreOutgoingRequests?: (url: string) => boolean;
 }
 
-const instrumentOtelNodeFetch = generateInstrumentOnce<UndiciInstrumentationConfig>(INTEGRATION_NAME, config => {
-  return new UndiciInstrumentation(config);
-});
+const instrumentOtelNodeFetch = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  UndiciInstrumentation,
+  (options: NodeFetchOptions) => {
+    return getConfigWithDefaults(options);
+  },
+);
 
-const instrumentSentryNodeFetch = generateInstrumentOnce<SentryNodeFetchInstrumentationOptions>(
+const instrumentSentryNodeFetch = generateInstrumentOnce(
   `${INTEGRATION_NAME}.sentry`,
-  config => {
-    return new SentryNodeFetchInstrumentation(config);
+  SentryNodeFetchInstrumentation,
+  (options: NodeFetchOptions) => {
+    return options;
   },
 );
 
@@ -52,8 +56,7 @@ const _nativeNodeFetchIntegration = ((options: NodeFetchOptions = {}) => {
 
       // This is the "regular" OTEL instrumentation that emits spans
       if (instrumentSpans) {
-        const instrumentationConfig = getConfigWithDefaults(options);
-        instrumentOtelNodeFetch(instrumentationConfig);
+        instrumentOtelNodeFetch(options);
       }
 
       // This is the Sentry-specific instrumentation that creates breadcrumbs & propagates traces

packages/node/src/integrations/tracing/graphql.ts

@@ -37,12 +37,13 @@ interface GraphqlOptions {
 
 const INTEGRATION_NAME = 'Graphql';
 
-export const instrumentGraphql = generateInstrumentOnce<GraphqlOptions>(
+export const instrumentGraphql = generateInstrumentOnce(
   INTEGRATION_NAME,
-  (_options: GraphqlOptions = {}) => {
+  GraphQLInstrumentation,
+  (_options: GraphqlOptions) => {
     const options = getOptionsWithDefaults(_options);
 
-    return new GraphQLInstrumentation({
+    return {
       ...options,
       responseHook(span) {
         addOriginToSpan(span, 'auto.graphql.otel.graphql');
@@ -73,7 +74,7 @@ export const instrumentGraphql = generateInstrumentOnce<GraphqlOptions>(
           }
         }
       },
-    });
+    };
   },
 );
 

packages/node/src/otel/instrument.ts

@@ -3,16 +3,47 @@ import { type Instrumentation, registerInstrumentations } from '@opentelemetry/i
 /** Exported only for tests. */
 export const INSTRUMENTED: Record<string, Instrumentation> = {};
 
-/**
- * Instrument an OpenTelemetry instrumentation once.
- * This will skip running instrumentation again if it was already instrumented.
- */
+export function generateInstrumentOnce<
+  Options,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  InstrumentationClass extends new (...args: any[]) => Instrumentation,
+>(
+  name: string,
+  instrumentationClass: InstrumentationClass,
+  optionsCallback: (options: Options) => ConstructorParameters<InstrumentationClass>[0],
+): ((options: Options) => InstanceType<InstrumentationClass>) & { id: string };
 export function generateInstrumentOnce<
   Options = unknown,
   InstrumentationInstance extends Instrumentation = Instrumentation,
 >(
   name: string,
   creator: (options?: Options) => InstrumentationInstance,
+): ((options?: Options) => InstrumentationInstance) & { id: string };
+/**
+ * Instrument an OpenTelemetry instrumentation once.
+ * This will skip running instrumentation again if it was already instrumented.
+ */
+export function generateInstrumentOnce<Options>(
+  name: string,
+  creatorOrClass: (new (...args: any[]) => Instrumentation) | ((options?: Options) => Instrumentation),
+  optionsCallback?: (options: Options) => unknown,
+): ((options: Options) => Instrumentation) & { id: string } {
+  if (optionsCallback) {
+    return _generateInstrumentOnceWithOptions(
+      name,
+      creatorOrClass as new (...args: unknown[]) => Instrumentation,
+      optionsCallback,
+    );
+  }
+
+  return _generateInstrumentOnce(name, creatorOrClass as (options?: Options) => Instrumentation);
+}
+
+// The plain version without handling of options
+// Should not be used with custom options that are mutated in the creator!
+function _generateInstrumentOnce<Options = unknown, InstrumentationInstance extends Instrumentation = Instrumentation>(
+  name: string,
+  creator: (options?: Options) => InstrumentationInstance,
 ): ((options?: Options) => InstrumentationInstance) & { id: string } {
   return Object.assign(
     (options?: Options) => {
@@ -38,6 +69,40 @@ export function generateInstrumentOnce<
   );
 }
 
+// This version handles options properly
+function _generateInstrumentOnceWithOptions<
+  Options,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  InstrumentationClass extends new (...args: any[]) => Instrumentation,
+>(
+  name: string,
+  instrumentationClass: InstrumentationClass,
+  optionsCallback: (options: Options) => ConstructorParameters<InstrumentationClass>[0],
+): ((options: Options) => InstanceType<InstrumentationClass>) & { id: string } {
+  return Object.assign(
+    (_options: Options) => {
+      const options = optionsCallback(_options);
+
+      const instrumented = INSTRUMENTED[name] as InstanceType<InstrumentationClass> | undefined;
+      if (instrumented) {
+        // Ensure we update options
+        instrumented.setConfig(options);
+        return instrumented;
+      }
+
+      const instrumentation = new instrumentationClass(options) as InstanceType<InstrumentationClass>;
+      INSTRUMENTED[name] = instrumentation;
+
+      registerInstrumentations({
+        instrumentations: [instrumentation],
+      });
+
+      return instrumentation;
+    },
+    { id: name },
+  );
+}
+
 /**
  * Ensure a given callback is called when the instrumentation is actually wrapping something.
  * This can be used to ensure some logic is only called when the instrumentation is actually active.

packages/remix/src/server/integrations/opentelemetry.ts

@@ -7,22 +7,24 @@ import type { RemixOptions } from '../../utils/remixOptions';
 
 const INTEGRATION_NAME = 'Remix';
 
-const instrumentRemix = generateInstrumentOnce<RemixOptions>(
-  INTEGRATION_NAME,
-  (_options?: RemixOptions) =>
-    new RemixInstrumentation({
-      actionFormDataAttributes: _options?.sendDefaultPii ? _options?.captureActionFormDataKeys : undefined,
-    }),
-);
+interface RemixInstrumentationOptions {
+  actionFormDataAttributes?: Record<string, string | boolean>;
+}
+
+const instrumentRemix = generateInstrumentOnce(INTEGRATION_NAME, (options?: RemixInstrumentationOptions) => {
+  return new RemixInstrumentation(options);
+});
 
 const _remixIntegration = (() => {
   return {
     name: 'Remix',
     setupOnce() {
       const client = getClient();
-      const options = client?.getOptions();
+      const options = client?.getOptions() as RemixOptions | undefined;
 
-      instrumentRemix(options);
+      instrumentRemix({
+        actionFormDataAttributes: options?.sendDefaultPii ? options?.captureActionFormDataKeys : undefined,
+      });
     },
 
     setup(client: Client) {