ref

Author: mydea

packages/server-utils/src/integrations/tracing-channel/express/index.ts

@@ -1,36 +1,19 @@
-import * as diagnosticsChannel from 'node:diagnostics_channel';
 import type { IntegrationFn } from '@sentry/core';
-import { defineIntegration, waitForTracingChannelBinding } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
 import type { ExpressIntegrationOptions } from './types';
 import { instrumentExpress } from './instrumentation';
 import { expressModuleNames } from '../../../orchestrion/config/express';
-import { instrumentOrchestrion, instrumentOrchestrionLazy } from '../../../orchestrion/instrumentation';
+import { invokeOrchestrionInstrumentation } from '../../../orchestrion/instrumentation';
 
 // NOTE: this uses the same name as the OTel integration by design.
 // When enabled, the OTel 'Express' integration is omitted from the default set.
 const INTEGRATION_NAME = 'Express' as const;
 
 const _expressChannelIntegration = ((options: ExpressIntegrationOptions = {}) => {
-  // `tracingChannel` is unavailable before Node 18.19 so do nothing in that case.
-  if (!diagnosticsChannel.tracingChannel) {
-    return {
-      name: INTEGRATION_NAME,
-    };
-  }
-
-  const instrumentFn = () => {
-    instrumentExpress(options, diagnosticsChannel.tracingChannel);
-  };
-
   return {
     name: INTEGRATION_NAME,
-    setupOnce() {
-      waitForTracingChannelBinding(() => {
-        instrumentOrchestrion(expressModuleNames, instrumentFn);
-      });
-    },
     setup(client) {
-      instrumentOrchestrionLazy(client, expressModuleNames, instrumentFn);
+      invokeOrchestrionInstrumentation(client, expressModuleNames, instrumentExpress, [options]);
     },
   };
 }) satisfies IntegrationFn;

packages/server-utils/src/integrations/tracing-channel/express/instrumentation.ts

@@ -1,4 +1,4 @@
-import type * as diagnosticsChannel from 'node:diagnostics_channel';
+import * as diagnosticsChannel from 'node:diagnostics_channel';
 import { HTTP_ROUTE } from '@sentry/conventions/attributes';
 import type { Span } from '@sentry/core';
 import {
@@ -45,16 +45,8 @@ const ATTR_EXPRESS_TYPE = 'express.type';
 
 const NOOP = (): void => {};
 
-let _isInstrumented = false;
-
-export function instrumentExpress(
-  options: ExpressIntegrationOptions,
-  tracingChannel: typeof diagnosticsChannel.tracingChannel,
-): void {
-  if (_isInstrumented) {
-    return;
-  }
-  _isInstrumented = true;
+export function instrumentExpress(options: ExpressIntegrationOptions): void {
+  const tracingChannel = diagnosticsChannel.tracingChannel;
 
   // Record each layer's registered path *pattern* as it is registered, so the
   // matched route can be reconstructed with its parameters intact at request

packages/server-utils/src/orchestrion/instrumentation.ts

@@ -1,44 +1,58 @@
 import type { Client } from '@sentry/core';
-import { addNonEnumerableProperty } from '@sentry/core';
+import { addNonEnumerableProperty, waitForTracingChannelBinding } from '@sentry/core';
 import { getOrchestrionInjectedModules } from './detect';
+import * as diagnosticsChannel from 'node:diagnostics_channel';
 
 const INSTRUMENTATION_FN_SYMBOL = Symbol.for('InstrumentationFn');
-type InstrumentationFn = (() => void) & { [INSTRUMENTATION_FN_SYMBOL]?: boolean };
+// oxlint-disable-next-line typescript/no-explicit-any
+type InstrumentationFn = ((...args: any[]) => void) & { [INSTRUMENTATION_FN_SYMBOL]?: boolean };
 
 /**
- * Instrument the provided callback to run when one of the provided module names has been orchestrion-injected already.
- * Make sure to pass the same callback instance to this as is passed to `instrumentOrchestrionLazy`.
+ * Run the provided instrumentation callback when one of the provided module names is orchestrion-injected.
+ * If it is already injected, it will invoce the callback immediately (e.g. when build-time injection is used).
+ * If runtime injection is used, it may invoke the callback at a later point in time, when the injection actually happens.
+ * The callback will never be invoked more than once.
  */
-export function instrumentOrchestrion(moduleNames: string[], callback: InstrumentationFn) {
+export function invokeOrchestrionInstrumentation<Callback extends InstrumentationFn>(
+  client: Client,
+  moduleNames: string[],
+  callback: Callback,
+  args: Parameters<Callback>,
+) {
+  // `tracingChannel` is unavailable before Node 18.19 so do nothing in that case.
+  if (!diagnosticsChannel.tracingChannel) {
+    return;
+  }
+
+  // If already injected, skip
   if (hasBeenInjected(callback)) {
     return;
   }
 
-  const modules = getOrchestrionInjectedModules();
-  if (moduleNames.some(name => modules.includes(name))) {
-    callback();
+  const instrumentationFn = () => {
     markAsInjected(callback);
-  }
-}
 
-/**
- * Run the provided instrumentation callback when one of the provided module names has been orchestrion-injected at runtime.
- * This listens to the `orchestrion.module-runtime-injected` event and runs the callback when the event is emitted.
- * Make sure to pass the same callback instance to this as is passed to `instrumentOrchestrion`.
- */
-export function instrumentOrchestrionLazy(client: Client, moduleNames: string[], callback: InstrumentationFn) {
-  if (hasBeenInjected(callback)) {
+    waitForTracingChannelBinding(() => {
+      callback(...args);
+    });
+  };
+
+  // First, check if the modules have been injected already
+  const modules = getOrchestrionInjectedModules();
+  if (moduleNames.some(name => modules.includes(name))) {
+    instrumentationFn();
     return;
   }
 
+  // Then, register a listener for the `orchestrion.module-runtime-injected` event
   const cleanup = client.on('orchestrion.module-runtime-injected', (moduleName: string) => {
+    if (hasBeenInjected(callback)) {
+      cleanup();
+      return;
+    }
+
     if (moduleNames.includes(moduleName)) {
-      if (hasBeenInjected(callback)) {
-        cleanup();
-        return;
-      }
-      callback();
-      markAsInjected(callback);
+      instrumentationFn();
       cleanup();
     }
   });