WIP express example

Author: mydea

packages/core/src/index.ts

@@ -137,6 +137,7 @@ export type {
   ExpressHandlerOptions,
   ExpressMiddleware,
   ExpressErrorMiddleware,
+  ExpressModuleExport,
 } from './integrations/express/types';
 export { dedupeIntegration } from './integrations/dedupe';
 export { extraErrorDataIntegration } from './integrations/extraerrordata';

packages/node-core/src/module-wrapper/index.ts

@@ -29,13 +29,13 @@ export interface ModuleWrapperFileOptions<TOptions = unknown> {
 }
 
 /** Options for registering a module wrapper */
-export interface ModuleWrapperOptions<TOptions = unknown> {
+export interface ModuleWrapperOptions<TModuleExports = unknown, TOptions = unknown> {
   /** Module name to wrap (e.g., 'express', 'pg', '@prisma/client') */
   moduleName: string;
   /** Semver ranges for supported versions (e.g., ['>=4.0.0 <5.0.0']) */
   supportedVersions: string[];
   /** Function to patch the module's exports. Use getOptions() to access current options at runtime. */
-  patch: (moduleExports: unknown, getOptions: () => TOptions | undefined, version?: string) => unknown;
+  patch: (moduleExports: TModuleExports, getOptions: () => TOptions | undefined, version?: string) => unknown;
   /** Optional array of specific files within the module to patch */
   files?: ModuleWrapperFileOptions<TOptions>[];
   /** Optional configuration options that can be updated on subsequent calls */
@@ -69,7 +69,9 @@ export interface ModuleWrapperOptions<TOptions = unknown> {
  * });
  * ```
  */
-export function registerModuleWrapper<TOptions = unknown>(wrapperOptions: ModuleWrapperOptions<TOptions>): void {
+export function registerModuleWrapper<TModuleExports = unknown, TOptions = unknown>(
+  wrapperOptions: ModuleWrapperOptions<TModuleExports, TOptions>,
+): void {
   const { moduleName, supportedVersions, patch, files, options } = wrapperOptions;
 
   // Always update the stored options (even if already registered)
@@ -102,7 +104,7 @@ export function registerModuleWrapper<TOptions = unknown>(wrapperOptions: Module
             `file hooks: ${files?.map(f => f.name).join(', ')}`,
           );
 
-        return patch(exports, getOptions, version);
+        return patch(exports as TModuleExports, getOptions, version);
       }
     } else if (files) {
       // Check if this is one of the specified files
@@ -157,7 +159,7 @@ export function registerModuleWrapper<TOptions = unknown>(wrapperOptions: Module
             `file hooks: ${files?.map(f => f.name).join(', ')}`,
           );
 
-        return patch(exports, getOptions, version);
+        return patch(exports as TModuleExports, getOptions, version);
       }
     } else if (files) {
       for (const file of files) {

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

@@ -1,16 +1,13 @@
-// 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 ExpressModuleExport,
   type IntegrationFn,
   debug,
   patchExpressModule,
-  SDK_VERSION,
   defineIntegration,
   setupExpressErrorHandler as coreSetupExpressErrorHandler,
   type ExpressHandlerOptions,
@@ -19,6 +16,7 @@ export { expressErrorHandler } from '@sentry/core';
 import { DEBUG_BUILD } from '../../debug-build';
 
 const INTEGRATION_NAME = 'Express';
+const MODULE_NAME = 'express';
 const SUPPORTED_VERSIONS = ['>=4.0.0 <6'];
 
 export function setupExpressErrorHandler(
@@ -30,44 +28,44 @@ export function setupExpressErrorHandler(
   ensureIsWrapped(app.use, 'express');
 }
 
-export type ExpressInstrumentationConfig = InstrumentationConfig &
-  Omit<ExpressIntegrationOptions, 'express' | 'onRouteResolved'>;
+export type ExpressInstrumentationConfig = Omit<ExpressIntegrationOptions, 'onRouteResolved'>;
 
-export const instrumentExpress = generateInstrumentOnce(
-  INTEGRATION_NAME,
-  (options?: ExpressInstrumentationConfig) => new ExpressInstrumentation(options),
-);
-
-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(express, () => ({
-            ...this.getConfig(),
-            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<ExpressModuleExport, ExpressInstrumentationConfig>({
+    moduleName: MODULE_NAME,
+    supportedVersions: SUPPORTED_VERSIONS,
+    options,
+    patch: (moduleExports, getOptions) => {
+      try {
+        patchExpressModule(moduleExports, () => ({
+          ...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;
+    },
+  });
 }
+
+// Add id property for compatibility with preloadOpenTelemetry logging
+instrumentExpress.id = INTEGRATION_NAME;
+
 const _expressIntegration = ((options?: ExpressInstrumentationConfig) => {
   return {
     name: INTEGRATION_NAME,