WIP express example

Author: mydea

packages/core/src/integrations/express/index.ts

@@ -71,9 +71,9 @@ const getExpressExport = (express: ExpressModuleExport): ExpressExport =>
  *
  * Sentry.patchExpressModule({ express })
  */
-export const patchExpressModule = (options: ExpressIntegrationOptions) => {
+export const patchExpressModule = (moduleExports: ExpressModuleExport, getOptions: () => ExpressIntegrationOptions) => {
   // pass in the require() or import() result of express
-  const express = getExpressExport(options.express);
+  const express = getExpressExport(moduleExports);
   const routerProto: ExpressRouterv4 | ExpressRouterv5 | undefined = isExpressWithRouterPrototype(express)
     ? express.Router.prototype // Express v5
     : isExpressWithoutRouterPrototype(express)
@@ -93,7 +93,7 @@ export const patchExpressModule = (options: ExpressIntegrationOptions) => {
       function routeTrace(this: ExpressRouter, ...args: Parameters<typeof originalRouteMethod>[]) {
         const route = originalRouteMethod.apply(this, args);
         const layer = this.stack[this.stack.length - 1] as ExpressLayer;
-        patchLayer(options, layer, getLayerPath(args));
+        patchLayer(getOptions, layer, getLayerPath(args));
         return route;
       },
     );
@@ -113,7 +113,7 @@ export const patchExpressModule = (options: ExpressIntegrationOptions) => {
         if (!layer) {
           return route;
         }
-        patchLayer(options, layer, getLayerPath(args));
+        patchLayer(getOptions, layer, getLayerPath(args));
         return route;
       },
     );
@@ -141,7 +141,7 @@ export const patchExpressModule = (options: ExpressIntegrationOptions) => {
         if (router) {
           const layer = router.stack[router.stack.length - 1];
           if (layer) {
-            patchLayer(options, layer, getLayerPath(args));
+            patchLayer(getOptions, layer, getLayerPath(args));
           }
         }
         return route;

packages/core/src/integrations/express/patch-layer.ts

@@ -61,7 +61,7 @@ export type ExpressPatchLayerOptions = Pick<
   'onRouteResolved' | 'ignoreLayers' | 'ignoreLayersType'
 >;
 
-export function patchLayer(options: ExpressPatchLayerOptions, maybeLayer?: ExpressLayer, layerPath?: string): void {
+export function patchLayer(getOptions: () => ExpressPatchLayerOptions, maybeLayer?: ExpressLayer, layerPath?: string): void {
   if (!maybeLayer?.handle) {
     return;
   }
@@ -86,6 +86,8 @@ export function patchLayer(options: ExpressPatchLayerOptions, maybeLayer?: Expre
     //oxlint-disable-next-line no-explicit-any
     ...otherArgs: any[]
   ) {
+    const options = getOptions();
+
     // Set normalizedRequest here because expressRequestHandler middleware
     // (registered via setupExpressErrorHandler) is added after routes and
     // therefore never runs for successful requests — route handlers typically

packages/core/src/integrations/express/types.ts

@@ -136,7 +136,6 @@ export type ExpressRouter = {
 export type IgnoreMatcher = string | RegExp | ((name: string) => boolean);
 
 export type ExpressIntegrationOptions = {
-  express: ExpressModuleExport; //Express
   /** Ignore specific based on their name */
   ignoreLayers?: IgnoreMatcher[];
   /** Ignore specific layers based on their type */

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

@@ -1,23 +1,21 @@
-// Automatic istrumentation for Express using OTel
-import type { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
 import { context } from '@opentelemetry/api';
 import { getRPCMetadata, RPCType } from '@opentelemetry/core';
 
-import { ensureIsWrapped, generateInstrumentOnce } from '@sentry/node-core';
+import { ensureIsWrapped, registerModuleWrapper } from '@sentry/node-core';
 import {
   type ExpressIntegrationOptions,
   type IntegrationFn,
   debug,
   patchExpressModule,
-  SDK_VERSION,
   defineIntegration,
   setupExpressErrorHandler as coreSetupExpressErrorHandler,
   type ExpressHandlerOptions,
 } from '@sentry/core';
 export { expressErrorHandler } from '@sentry/core';
 import { DEBUG_BUILD } from '../../debug-build';
 
+type ExpressModuleExport = Parameters<typeof patchExpressModule>[0];
+
 const INTEGRATION_NAME = 'Express';
 const SUPPORTED_VERSIONS = ['>=4.0.0 <6'];
 
@@ -30,47 +28,46 @@ export function setupExpressErrorHandler(
   ensureIsWrapped(app.use, 'express');
 }
 
-export type ExpressInstrumentationConfig = InstrumentationConfig &
-  Omit<ExpressIntegrationOptions, 'express' | 'onRouteResolved'>;
-
-export const instrumentExpress = generateInstrumentOnce(
-  INTEGRATION_NAME,
-  (options?: ExpressInstrumentationConfig) => new ExpressInstrumentation(options),
-);
+export type ExpressInstrumentationConfig = Omit<ExpressIntegrationOptions, 'onRouteResolved'>;
 
-export class ExpressInstrumentation extends InstrumentationBase<ExpressInstrumentationConfig> {
-  public constructor(config: ExpressInstrumentationConfig = {}) {
-    super('sentry-express', SDK_VERSION, config);
-  }
-  public init(): InstrumentationNodeModuleDefinition {
-    const module = new InstrumentationNodeModuleDefinition(
-      'express',
-      SUPPORTED_VERSIONS,
-      express => {
-        try {
-          patchExpressModule({
-            ...this.getConfig(),
-            express,
-            onRouteResolved(route) {
-              const rpcMetadata = getRPCMetadata(context.active());
-              if (route && rpcMetadata?.type === RPCType.HTTP) {
-                rpcMetadata.route = route;
-              }
-            },
-          });
-        } catch (e) {
-          DEBUG_BUILD && debug.error('Failed to patch express module:', e);
-        }
-        return express;
-      },
-      // we do not ever actually unpatch in our SDKs
-      express => express,
-    );
-    return module;
-  }
+/**
+ * Instrument Express using registerModuleWrapper.
+ * This registers hooks for both CJS and ESM module loading.
+ *
+ * Calling this multiple times is safe:
+ * - Hooks are only registered once (first call)
+ * - Options are updated on each call
+ * - Use getOptions() in the patch to access current options at runtime
+ */
+export function instrumentExpress(options: ExpressInstrumentationConfig = {}): void {
+  registerModuleWrapper<ExpressInstrumentationConfig>({
+    moduleName: 'express',
+    supportedVersions: SUPPORTED_VERSIONS,
+    options,
+    patch: (moduleExports, getOptions) => {
+      const express = moduleExports as ExpressModuleExport;
+      try {
+        patchExpressModule(express, () => ({
+          ...getOptions(),
+          onRouteResolved(route) {
+            const rpcMetadata = getRPCMetadata(context.active());
+            if (route && rpcMetadata?.type === RPCType.HTTP) {
+              rpcMetadata.route = route;
+            }
+          },
+        }));
+      } catch (e) {
+        DEBUG_BUILD && debug.error('Failed to patch express module:', e);
+      }
+      return moduleExports;
+    },
+  });
 }
 
-const _expressInstrumentation = ((options?: ExpressInstrumentationConfig) => {
+// Add id property for compatibility with preloadOpenTelemetry logging
+instrumentExpress.id = INTEGRATION_NAME;
+
+const _expressIntegration = ((options?: ExpressInstrumentationConfig) => {
   return {
     name: INTEGRATION_NAME,
     setupOnce() {
@@ -79,4 +76,4 @@ const _expressInstrumentation = ((options?: ExpressInstrumentationConfig) => {
   };
 }) satisfies IntegrationFn;
 
-export const expressIntegration = defineIntegration(_expressInstrumentation);
+export const expressIntegration = defineIntegration(_expressIntegration);