@reproapp/node-sdk 0.0.29 → 0.0.31

package/dist/index.js

@@ -6,6 +6,7 @@ const async_hooks_1 = require("async_hooks");
 const crypto_1 = require("crypto");
 const module_1 = require("module");
 const path_1 = require("path");
+const url_1 = require("url");
 const client_1 = require("./ingest/client");
 const privacy_1 = require("./privacy");
 /**
@@ -295,6 +296,7 @@ const REQUEST_START_HEADER = 'x-bug-request-start';
 const REPRO_QUERY_SESSION_PARAM = '__repro_sid';
 const REPRO_QUERY_ACTION_PARAM = '__repro_aid';
 const REPRO_QUERY_START_PARAM = '__repro_start';
+const REPRO_REQUEST_MIDDLEWARE_RAN = Symbol.for('__repro_request_middleware_ran');
 const KAFKA_HEADER_TRACE_ID = 'x-repro-trace-id';
 const KAFKA_HEADER_SPAN_ID = 'x-repro-span-id';
 const KAFKA_HEADER_PARENT_SPAN_ID = 'x-repro-parent-span-id';
@@ -4027,6 +4029,22 @@ function reproMiddleware(cfg) {
     const masking = normalizeMaskingConfig(cfg.masking);
     patchMongoDb(cfg);
     return async function (req, res, next) {
+        const reqAny = req;
+        if (reqAny?.[REPRO_REQUEST_MIDDLEWARE_RAN]) {
+            return next();
+        }
+        try {
+            Object.defineProperty(reqAny, REPRO_REQUEST_MIDDLEWARE_RAN, {
+                value: true,
+                configurable: true,
+            });
+        }
+        catch {
+            try {
+                reqAny[REPRO_REQUEST_MIDDLEWARE_RAN] = true;
+            }
+            catch { }
+        }
         const querySid = readRequestQueryParam(req, REPRO_QUERY_SESSION_PARAM);
         const queryAid = readRequestQueryParam(req, REPRO_QUERY_ACTION_PARAM);
         const queryTs = readRequestQueryNumber(req, REPRO_QUERY_START_PARAM);
@@ -4063,30 +4081,50 @@ function reproMiddleware(cfg) {
         const maskReq = { method: String(req.method || 'GET').toUpperCase(), path: urlPathOnly, key };
         const requestHeaders = sanitizeHeaders(req.headers, cfg.captureHeaders);
         beginSessionRequest(sid);
-        // ---- response body capture (unchanged) ----
+        // ---- response body capture ----
         let capturedBody = undefined;
-        const origJson = res.json.bind(res);
-        res.json = (body) => { capturedBody = body; return origJson(body); };
-        const origSend = res.send.bind(res);
-        res.send = (body) => {
-            if (capturedBody === undefined) {
-                capturedBody = coerceBodyToStorable(body, res.getHeader?.('content-type'));
-            }
-            return origSend(body);
-        };
-        const origWrite = res.write.bind(res);
-        const origEnd = res.end.bind(res);
+        const originalJson = res.json;
+        if (typeof originalJson === 'function') {
+            const origJson = originalJson.bind(res);
+            res.json = (body) => { capturedBody = body; return origJson(body); };
+        }
+        const originalSend = res.send;
+        if (typeof originalSend === 'function') {
+            const origSend = originalSend.bind(res);
+            res.send = (body) => {
+                if (capturedBody === undefined) {
+                    capturedBody = coerceBodyToStorable(body, res.getHeader?.('content-type'));
+                }
+                return origSend(body);
+            };
+        }
+        const origWrite = typeof res.write === 'function'
+            ? res.write.bind(res)
+            : null;
+        const origEnd = typeof res.end === 'function'
+            ? res.end.bind(res)
+            : null;
         const chunks = [];
-        res.write = (chunk, ...args) => { try {
-            if (chunk != null)
-                chunks.push(chunk);
+        if (origWrite) {
+            res.write = (chunk, ...args) => {
+                try {
+                    if (chunk != null)
+                        chunks.push(chunk);
+                }
+                catch { }
+                return origWrite(chunk, ...args);
+            };
         }
-        catch { } return origWrite(chunk, ...args); };
-        res.end = (chunk, ...args) => { try {
-            if (chunk != null)
-                chunks.push(chunk);
+        if (origEnd) {
+            res.end = (chunk, ...args) => {
+                try {
+                    if (chunk != null)
+                        chunks.push(chunk);
+                }
+                catch { }
+                return origEnd(chunk, ...args);
+            };
         }
-        catch { } return origEnd(chunk, ...args); };
         // ---- our ALS (unchanged) ----
         const tracerApiWithTrace = __TRACER__;
         const runInTrace = (fn) => {
@@ -7562,6 +7600,8 @@ function patchRedis(cfg) {
 exports.patchRedis = patchRedis;
 const mongoDbPatchConfigs = [];
 let mongoDbRequireHookInstalled = false;
+let mongoDbImportHookInstalled = false;
+let mongoDbImportHookReady = null;
 const MONGODB_PROMISE_OPS = [
     'insertOne',
     'insertMany',
@@ -7581,6 +7621,11 @@ const MONGODB_PROMISE_OPS = [
 ];
 const MONGODB_CURSOR_OPS = ['find', 'aggregate'];
 const MONGODB_CURSOR_TERMINALS = ['toArray', 'next', 'forEach'];
+function registerMongoDbPatchConfig(cfg) {
+    if (!mongoDbPatchConfigs.includes(cfg)) {
+        mongoDbPatchConfigs.push(cfg);
+    }
+}
 function resolveMongoDbRuntimeContext(cfg) {
     const ctx = getCtx();
     const fallback = cfg.resolveContext?.() ?? {};
@@ -7590,6 +7635,18 @@ function resolveMongoDbRuntimeContext(cfg) {
         aid: ctx.aid ?? fallback.aid ?? null,
     };
 }
+function resolveMongoDbCaptureContext() {
+    for (let i = mongoDbPatchConfigs.length - 1; i >= 0; i -= 1) {
+        const cfg = mongoDbPatchConfigs[i];
+        if (!cfg)
+            continue;
+        const { sid, aid } = resolveMongoDbRuntimeContext(cfg);
+        if (sid) {
+            return { cfg, sid, aid };
+        }
+    }
+    return null;
+}
 function resolveMongoCollectionName(collection) {
     const candidates = [
         collection?.collectionName,
@@ -7874,10 +7931,11 @@ function patchMongoCollectionMethod(proto, op, cursorOp, cfg) {
         if (isNativeMongoSuppressed(collection, op)) {
             return original.apply(this, args);
         }
-        const { sid, aid } = resolveMongoDbRuntimeContext(cfg);
-        if (!sid) {
+        const captureContext = resolveMongoDbCaptureContext();
+        if (!captureContext) {
             return original.apply(this, args);
         }
+        const { cfg: activeCfg, sid, aid } = captureContext;
         const spanContext = captureSpanContextFromTracer(this);
         const t0 = Date.now();
         const dbName = resolveMongoDbName(this);
@@ -7888,7 +7946,7 @@ function patchMongoCollectionMethod(proto, op, cursorOp, cfg) {
             if (emitted)
                 return;
             emitted = true;
-            emitDbQuery(cfg, sid, aid ?? undefined, {
+            emitDbQuery(activeCfg, sid, aid ?? undefined, {
                 type: 'mongo',
                 collection,
                 op,
@@ -7906,7 +7964,7 @@ function patchMongoCollectionMethod(proto, op, cursorOp, cfg) {
             if (emitted)
                 return;
             emitted = true;
-            emitDbQuery(cfg, sid, aid ?? undefined, {
+            emitDbQuery(activeCfg, sid, aid ?? undefined, {
                 type: 'mongo',
                 collection,
                 op,
@@ -7931,7 +7989,7 @@ function patchMongoCollectionMethod(proto, op, cursorOp, cfg) {
             const result = original.apply(this, actualArgs);
             if (cursorOp) {
                 return patchMongoCursorInstance(result, {
-                    cfg,
+                    cfg: activeCfg,
                     sid,
                     aid,
                     collection,
@@ -8016,6 +8074,7 @@ function patchMongoClientPrototype(proto, cfg) {
     };
 }
 function patchMongoDbFromModuleExports(mongoModule, cfg) {
+    registerMongoDbPatchConfig(cfg);
     if (!mongoModule)
         return;
     const constructors = new Set();
@@ -8071,9 +8130,46 @@ function installMongoDbRequireHook() {
     }
     catch { }
 }
+function installMongoDbImportHook() {
+    if (mongoDbImportHookInstalled)
+        return mongoDbImportHookReady ?? Promise.resolve();
+    mongoDbImportHookInstalled = true;
+    mongoDbImportHookReady = (async () => {
+        try {
+            const nodeModule = requireOptionalHostModule('node:module') ?? requireOptionalHostModule('module');
+            if (typeof nodeModule?.register !== 'function')
+                return;
+            const iitm = requireOptionalHostModule('import-in-the-middle');
+            const Hook = iitm?.Hook ?? iitm;
+            if (typeof Hook !== 'function')
+                return;
+            let waitForAllMessagesAcknowledged;
+            let registerOptions = { data: { include: ['mongodb'] } };
+            if (typeof iitm?.createAddHookMessageChannel === 'function') {
+                const channel = iitm.createAddHookMessageChannel();
+                registerOptions = channel.registerOptions;
+                waitForAllMessagesAcknowledged = channel.waitForAllMessagesAcknowledged;
+            }
+            nodeModule.register('import-in-the-middle/hook.mjs', (0, url_1.pathToFileURL)(__filename), registerOptions);
+            // eslint-disable-next-line no-new
+            new Hook(['mongodb'], (exports) => {
+                for (const cfg of mongoDbPatchConfigs) {
+                    patchMongoDbFromModuleExports(exports, cfg);
+                }
+                return exports;
+            });
+            if (waitForAllMessagesAcknowledged) {
+                await waitForAllMessagesAcknowledged();
+            }
+        }
+        catch { }
+    })();
+    return mongoDbImportHookReady;
+}
 function patchMongoDb(cfg) {
-    mongoDbPatchConfigs.push(cfg);
+    registerMongoDbPatchConfig(cfg);
     installMongoDbRequireHook();
+    void installMongoDbImportHook();
     const mongoModules = new Set();
     for (const loadedMongoModule of getLoadedModuleExportsByPackage('mongodb')) {
         mongoModules.add(loadedMongoModule);
@@ -8092,9 +8188,13 @@ const REPRO_AUTO_MIDDLEWARE_INSTALLED = Symbol.for('__repro_auto_middleware_inst
 const REPRO_AUTO_NEST_FACTORY_PATCHED = Symbol.for('__repro_auto_nest_factory_patched');
 const REPRO_AUTO_EXPRESS_LISTEN_PATCHED = Symbol.for('__repro_auto_express_listen_patched');
 const REPRO_AUTO_NEST_LISTEN_PATCHED = Symbol.for('__repro_auto_nest_listen_patched');
+const REPRO_AUTO_HTTP_CREATE_SERVER_PATCHED = Symbol.for('__repro_auto_http_create_server_patched');
+const REPRO_AUTO_HTTP_SERVER_PATCHED = Symbol.for('__repro_auto_http_server_patched');
+const REPRO_AUTO_HTTP_LISTENER_WRAPPED = Symbol.for('__repro_auto_http_listener_wrapped');
 const REPRO_AUTO_MONGOOSE_PLUGIN_PATCHED = Symbol.for('__repro_auto_mongoose_plugin_patched');
 let reproAutoMiddlewareConfig = null;
 const mongoosePluginConfigs = [];
+const httpRequestListenerWrappers = new WeakMap();
 let frameworkRequireHookInstalled = false;
 let mongooseRequireHookInstalled = false;
 function hasMarker(target, marker) {
@@ -8199,6 +8299,81 @@ function patchExpressFromModuleExports(expressModule) {
     setMarker(wrappedListen, REPRO_AUTO_EXPRESS_LISTEN_PATCHED);
     application.listen = wrappedListen;
 }
+function wrapHttpRequestListener(listener, cfg) {
+    if (typeof listener !== 'function')
+        return listener;
+    if (hasMarker(listener, REPRO_AUTO_HTTP_LISTENER_WRAPPED))
+        return listener;
+    const existing = httpRequestListenerWrappers.get(listener);
+    if (existing)
+        return existing;
+    const middleware = reproMiddleware(cfg);
+    const wrapped = function reproPatchedHttpRequestListener(req, res) {
+        return middleware(req, res, (err) => {
+            if (err) {
+                try {
+                    if (!res.headersSent) {
+                        res.statusCode = 500;
+                        res.end('Internal Server Error');
+                        return undefined;
+                    }
+                }
+                catch { }
+                throw err;
+            }
+            return listener.call(this, req, res);
+        });
+    };
+    setMarker(wrapped, REPRO_AUTO_HTTP_LISTENER_WRAPPED);
+    httpRequestListenerWrappers.set(listener, wrapped);
+    return wrapped;
+}
+function patchHttpServerRequestListenerMethods(server) {
+    const cfg = reproAutoMiddlewareConfig;
+    if (!cfg || !server || hasMarker(server, REPRO_AUTO_HTTP_SERVER_PATCHED))
+        return;
+    for (const methodName of ['on', 'addListener', 'prependListener', 'once']) {
+        const original = server[methodName];
+        if (typeof original !== 'function')
+            continue;
+        server[methodName] = function reproPatchedHttpServerListenerMethod(...args) {
+            if (args[0] === 'request' && typeof args[1] === 'function' && reproAutoMiddlewareConfig) {
+                args[1] = wrapHttpRequestListener(args[1], reproAutoMiddlewareConfig);
+            }
+            return original.apply(this, args);
+        };
+    }
+    setMarker(server, REPRO_AUTO_HTTP_SERVER_PATCHED);
+}
+function patchHttpCreateServerFromModuleExports(httpModule) {
+    const original = httpModule?.createServer;
+    if (!httpModule || typeof original !== 'function')
+        return;
+    if (hasMarker(original, REPRO_AUTO_HTTP_CREATE_SERVER_PATCHED))
+        return;
+    const wrappedCreateServer = function reproPatchedHttpCreateServer(...args) {
+        const cfg = reproAutoMiddlewareConfig;
+        if (cfg) {
+            const listenerIndex = typeof args[0] === 'function'
+                ? 0
+                : typeof args[1] === 'function'
+                    ? 1
+                    : -1;
+            if (listenerIndex >= 0) {
+                args[listenerIndex] = wrapHttpRequestListener(args[listenerIndex], cfg);
+            }
+        }
+        const server = original.apply(this, args);
+        patchHttpServerRequestListenerMethods(server);
+        return server;
+    };
+    setMarker(wrappedCreateServer, REPRO_AUTO_HTTP_CREATE_SERVER_PATCHED);
+    httpModule.createServer = wrappedCreateServer;
+}
+function patchHttpServerAutoAttach() {
+    patchHttpCreateServerFromModuleExports(requireOptionalHostModule('node:http') ?? requireOptionalHostModule('http'));
+    patchHttpCreateServerFromModuleExports(requireOptionalHostModule('node:https') ?? requireOptionalHostModule('https'));
+}
 function patchKnownFrameworkModules() {
     const nestModules = new Set();
     const resolvedNest = requireOptionalHostModule('@nestjs/core');
@@ -8502,6 +8677,7 @@ async function initRepro(cfg) {
     };
     shareRuntimePrivacyState(reproAutoMiddlewareConfig, integrationCfg);
     installFrameworkRequireHook();
+    patchHttpServerAutoAttach();
     patchKnownFrameworkModules();
     patchHttpClients({
         resolveContext: cfg.resolveContext,
@@ -8511,6 +8687,7 @@ async function initRepro(cfg) {
     patchAmqplib(integrationCfg);
     patchRedis(integrationCfg);
     patchMongoDb(integrationCfg);
+    await installMongoDbImportHook();
     patchSendgridMail(integrationCfg);
     patchMongooseIntegration(reproAutoMiddlewareConfig);
     await initializeRuntimePrivacyPolicyAtStartup(reproAutoMiddlewareConfig);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,7 @@
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build",
-    "test": "npm run build && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-capture-background.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-timeout.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js",
+    "test": "npm run build && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-capture-background.test.js && node test/init-auto-http-server.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-timeout.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js",
     "test:containers": "npm run build && node test/runtime-no-double-invoke.testcontainers.test.js && node test/wrap-plugin-super-call.testcontainers.test.js && node test/function-arg-identity.testcontainers.test.js"
   },
   "peerDependencies": {

package/src/index.ts

@@ -5,6 +5,7 @@ import { AsyncLocalStorage } from 'async_hooks';
 import { randomUUID } from 'crypto';
 import { createRequire } from 'module';
 import { join } from 'path';
+import { pathToFileURL } from 'url';
 import {
     configureIngestQueueDrain,
     enqueueIngestEntries,
@@ -313,6 +314,7 @@ const REQUEST_START_HEADER = 'x-bug-request-start';
 const REPRO_QUERY_SESSION_PARAM = '__repro_sid';
 const REPRO_QUERY_ACTION_PARAM = '__repro_aid';
 const REPRO_QUERY_START_PARAM = '__repro_start';
+const REPRO_REQUEST_MIDDLEWARE_RAN = Symbol.for('__repro_request_middleware_ran');
 const KAFKA_HEADER_TRACE_ID = 'x-repro-trace-id';
 const KAFKA_HEADER_SPAN_ID = 'x-repro-span-id';
 const KAFKA_HEADER_PARENT_SPAN_ID = 'x-repro-parent-span-id';
@@ -4916,6 +4918,19 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
     const masking = normalizeMaskingConfig(cfg.masking);
     patchMongoDb(cfg);
     return async function (req: Request, res: Response, next: NextFunction) {
+        const reqAny = req as any;
+        if (reqAny?.[REPRO_REQUEST_MIDDLEWARE_RAN]) {
+            return next();
+        }
+        try {
+            Object.defineProperty(reqAny, REPRO_REQUEST_MIDDLEWARE_RAN, {
+                value: true,
+                configurable: true,
+            });
+        } catch {
+            try { reqAny[REPRO_REQUEST_MIDDLEWARE_RAN] = true; } catch {}
+        }
+
         const querySid = readRequestQueryParam(req, REPRO_QUERY_SESSION_PARAM);
         const queryAid = readRequestQueryParam(req, REPRO_QUERY_ACTION_PARAM);
         const queryTs = readRequestQueryNumber(req, REPRO_QUERY_START_PARAM);
@@ -4955,24 +4970,44 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
         const requestHeaders = sanitizeHeaders(req.headers, cfg.captureHeaders);
         beginSessionRequest(sid);
 
-        // ---- response body capture (unchanged) ----
+        // ---- response body capture ----
         let capturedBody: any = undefined;
-        const origJson = res.json.bind(res as any);
-        (res as any).json = (body: any) => { capturedBody = body; return origJson(body); };
-
-        const origSend = res.send.bind(res as any);
-        (res as any).send = (body: any) => {
-            if (capturedBody === undefined) {
-                capturedBody = coerceBodyToStorable(body, res.getHeader?.('content-type'));
-            }
-            return origSend(body);
-        };
+        const originalJson = (res as any).json;
+        if (typeof originalJson === 'function') {
+            const origJson = originalJson.bind(res as any);
+            (res as any).json = (body: any) => { capturedBody = body; return origJson(body); };
+        }
+
+        const originalSend = (res as any).send;
+        if (typeof originalSend === 'function') {
+            const origSend = originalSend.bind(res as any);
+            (res as any).send = (body: any) => {
+                if (capturedBody === undefined) {
+                    capturedBody = coerceBodyToStorable(body, res.getHeader?.('content-type'));
+                }
+                return origSend(body);
+            };
+        }
 
-        const origWrite = (res as any).write.bind(res as any);
-        const origEnd = (res as any).end.bind(res as any);
+        const origWrite = typeof (res as any).write === 'function'
+            ? (res as any).write.bind(res as any)
+            : null;
+        const origEnd = typeof (res as any).end === 'function'
+            ? (res as any).end.bind(res as any)
+            : null;
         const chunks: Array<Buffer | string> = [];
-        (res as any).write = (chunk: any, ...args: any[]) => { try { if (chunk != null) chunks.push(chunk); } catch {} return origWrite(chunk, ...args); };
-        (res as any).end = (chunk?: any, ...args: any[]) => { try { if (chunk != null) chunks.push(chunk); } catch {} return origEnd(chunk, ...args); };
+        if (origWrite) {
+            (res as any).write = (chunk: any, ...args: any[]) => {
+                try { if (chunk != null) chunks.push(chunk); } catch {}
+                return origWrite(chunk, ...args);
+            };
+        }
+        if (origEnd) {
+            (res as any).end = (chunk?: any, ...args: any[]) => {
+                try { if (chunk != null) chunks.push(chunk); } catch {}
+                return origEnd(chunk, ...args);
+            };
+        }
 
         // ---- our ALS (unchanged) ----
         const tracerApiWithTrace = __TRACER__ as (TracerApi & { withTrace?: (id: string, fn: () => void) => void }) | null;
@@ -8776,6 +8811,8 @@ export type MongoDbPatchConfig = ReproMiddlewareConfig & {
 
 const mongoDbPatchConfigs: MongoDbPatchConfig[] = [];
 let mongoDbRequireHookInstalled = false;
+let mongoDbImportHookInstalled = false;
+let mongoDbImportHookReady: Promise<void> | null = null;
 
 const MONGODB_PROMISE_OPS = [
     'insertOne',
@@ -8798,6 +8835,12 @@ const MONGODB_PROMISE_OPS = [
 const MONGODB_CURSOR_OPS = ['find', 'aggregate'] as const;
 const MONGODB_CURSOR_TERMINALS = ['toArray', 'next', 'forEach'] as const;
 
+function registerMongoDbPatchConfig(cfg: MongoDbPatchConfig): void {
+    if (!mongoDbPatchConfigs.includes(cfg)) {
+        mongoDbPatchConfigs.push(cfg);
+    }
+}
+
 function resolveMongoDbRuntimeContext(cfg: MongoDbPatchConfig) {
     const ctx = getCtx();
     const fallback = cfg.resolveContext?.() ?? {};
@@ -8808,6 +8851,18 @@ function resolveMongoDbRuntimeContext(cfg: MongoDbPatchConfig) {
     };
 }
 
+function resolveMongoDbCaptureContext(): { cfg: MongoDbPatchConfig; sid: string; aid: string | null } | null {
+    for (let i = mongoDbPatchConfigs.length - 1; i >= 0; i -= 1) {
+        const cfg = mongoDbPatchConfigs[i];
+        if (!cfg) continue;
+        const { sid, aid } = resolveMongoDbRuntimeContext(cfg);
+        if (sid) {
+            return { cfg, sid, aid };
+        }
+    }
+    return null;
+}
+
 function resolveMongoCollectionName(collection: any): string {
     const candidates = [
         collection?.collectionName,
@@ -9108,10 +9163,11 @@ function patchMongoCollectionMethod(proto: any, op: string, cursorOp: boolean, c
             return original.apply(this, args);
         }
 
-        const { sid, aid } = resolveMongoDbRuntimeContext(cfg);
-        if (!sid) {
+        const captureContext = resolveMongoDbCaptureContext();
+        if (!captureContext) {
             return original.apply(this, args);
         }
+        const { cfg: activeCfg, sid, aid } = captureContext;
 
         const spanContext = captureSpanContextFromTracer(this);
         const t0 = Date.now();
@@ -9123,7 +9179,7 @@ function patchMongoCollectionMethod(proto: any, op: string, cursorOp: boolean, c
         const emitSuccess = (result: any) => {
             if (emitted) return;
             emitted = true;
-            emitDbQuery(cfg, sid, aid ?? undefined, {
+            emitDbQuery(activeCfg, sid, aid ?? undefined, {
                 type: 'mongo',
                 collection,
                 op,
@@ -9140,7 +9196,7 @@ function patchMongoCollectionMethod(proto: any, op: string, cursorOp: boolean, c
         const emitFailure = (error: any) => {
             if (emitted) return;
             emitted = true;
-            emitDbQuery(cfg, sid, aid ?? undefined, {
+            emitDbQuery(activeCfg, sid, aid ?? undefined, {
                 type: 'mongo',
                 collection,
                 op,
@@ -9165,7 +9221,7 @@ function patchMongoCollectionMethod(proto: any, op: string, cursorOp: boolean, c
             const result = original.apply(this, actualArgs);
             if (cursorOp) {
                 return patchMongoCursorInstance(result, {
-                    cfg,
+                    cfg: activeCfg,
                     sid,
                     aid,
                     collection,
@@ -9249,6 +9305,7 @@ function patchMongoClientPrototype(proto: any, cfg: MongoDbPatchConfig): void {
 }
 
 function patchMongoDbFromModuleExports(mongoModule: any, cfg: MongoDbPatchConfig): void {
+    registerMongoDbPatchConfig(cfg);
     if (!mongoModule) return;
     const constructors = new Set<any>();
     const addCtor = (candidate: any) => {
@@ -9309,9 +9366,50 @@ function installMongoDbRequireHook(): void {
     } catch {}
 }
 
+function installMongoDbImportHook(): Promise<void> {
+    if (mongoDbImportHookInstalled) return mongoDbImportHookReady ?? Promise.resolve();
+    mongoDbImportHookInstalled = true;
+
+    mongoDbImportHookReady = (async () => {
+        try {
+            const nodeModule = requireOptionalHostModule('node:module') ?? requireOptionalHostModule('module');
+            if (typeof nodeModule?.register !== 'function') return;
+
+            const iitm = requireOptionalHostModule('import-in-the-middle');
+            const Hook = iitm?.Hook ?? iitm;
+            if (typeof Hook !== 'function') return;
+
+            let waitForAllMessagesAcknowledged: undefined | (() => Promise<void>);
+            let registerOptions: any = { data: { include: ['mongodb'] } };
+            if (typeof iitm?.createAddHookMessageChannel === 'function') {
+                const channel = iitm.createAddHookMessageChannel();
+                registerOptions = channel.registerOptions;
+                waitForAllMessagesAcknowledged = channel.waitForAllMessagesAcknowledged;
+            }
+
+            nodeModule.register('import-in-the-middle/hook.mjs', pathToFileURL(__filename), registerOptions);
+
+            // eslint-disable-next-line no-new
+            new Hook(['mongodb'], (exports: any) => {
+                for (const cfg of mongoDbPatchConfigs) {
+                    patchMongoDbFromModuleExports(exports, cfg);
+                }
+                return exports;
+            });
+
+            if (waitForAllMessagesAcknowledged) {
+                await waitForAllMessagesAcknowledged();
+            }
+        } catch {}
+    })();
+
+    return mongoDbImportHookReady;
+}
+
 export function patchMongoDb(cfg: MongoDbPatchConfig): void {
-    mongoDbPatchConfigs.push(cfg);
+    registerMongoDbPatchConfig(cfg);
     installMongoDbRequireHook();
+    void installMongoDbImportHook();
 
     const mongoModules = new Set<any>();
     for (const loadedMongoModule of getLoadedModuleExportsByPackage('mongodb')) {
@@ -9331,10 +9429,14 @@ const REPRO_AUTO_MIDDLEWARE_INSTALLED = Symbol.for('__repro_auto_middleware_inst
 const REPRO_AUTO_NEST_FACTORY_PATCHED = Symbol.for('__repro_auto_nest_factory_patched');
 const REPRO_AUTO_EXPRESS_LISTEN_PATCHED = Symbol.for('__repro_auto_express_listen_patched');
 const REPRO_AUTO_NEST_LISTEN_PATCHED = Symbol.for('__repro_auto_nest_listen_patched');
+const REPRO_AUTO_HTTP_CREATE_SERVER_PATCHED = Symbol.for('__repro_auto_http_create_server_patched');
+const REPRO_AUTO_HTTP_SERVER_PATCHED = Symbol.for('__repro_auto_http_server_patched');
+const REPRO_AUTO_HTTP_LISTENER_WRAPPED = Symbol.for('__repro_auto_http_listener_wrapped');
 const REPRO_AUTO_MONGOOSE_PLUGIN_PATCHED = Symbol.for('__repro_auto_mongoose_plugin_patched');
 
 let reproAutoMiddlewareConfig: ReproMiddlewareConfig | null = null;
 const mongoosePluginConfigs: ReproMiddlewareConfig[] = [];
+const httpRequestListenerWrappers = new WeakMap<Function, Function>();
 let frameworkRequireHookInstalled = false;
 let mongooseRequireHookInstalled = false;
 
@@ -9435,6 +9537,82 @@ function patchExpressFromModuleExports(expressModule: any): void {
     application.listen = wrappedListen;
 }
 
+function wrapHttpRequestListener(listener: any, cfg: ReproMiddlewareConfig): any {
+    if (typeof listener !== 'function') return listener;
+    if (hasMarker(listener, REPRO_AUTO_HTTP_LISTENER_WRAPPED)) return listener;
+
+    const existing = httpRequestListenerWrappers.get(listener);
+    if (existing) return existing;
+
+    const middleware = reproMiddleware(cfg);
+    const wrapped = function reproPatchedHttpRequestListener(this: any, req: any, res: any) {
+        return middleware(req, res, (err?: any) => {
+            if (err) {
+                try {
+                    if (!res.headersSent) {
+                        res.statusCode = 500;
+                        res.end('Internal Server Error');
+                        return undefined;
+                    }
+                } catch {}
+                throw err;
+            }
+            return listener.call(this, req, res);
+        });
+    };
+    setMarker(wrapped, REPRO_AUTO_HTTP_LISTENER_WRAPPED);
+    httpRequestListenerWrappers.set(listener, wrapped);
+    return wrapped;
+}
+
+function patchHttpServerRequestListenerMethods(server: any): void {
+    const cfg = reproAutoMiddlewareConfig;
+    if (!cfg || !server || hasMarker(server, REPRO_AUTO_HTTP_SERVER_PATCHED)) return;
+
+    for (const methodName of ['on', 'addListener', 'prependListener', 'once']) {
+        const original = server[methodName];
+        if (typeof original !== 'function') continue;
+        server[methodName] = function reproPatchedHttpServerListenerMethod(this: any, ...args: any[]) {
+            if (args[0] === 'request' && typeof args[1] === 'function' && reproAutoMiddlewareConfig) {
+                args[1] = wrapHttpRequestListener(args[1], reproAutoMiddlewareConfig);
+            }
+            return original.apply(this, args);
+        };
+    }
+    setMarker(server, REPRO_AUTO_HTTP_SERVER_PATCHED);
+}
+
+function patchHttpCreateServerFromModuleExports(httpModule: any): void {
+    const original = httpModule?.createServer;
+    if (!httpModule || typeof original !== 'function') return;
+    if (hasMarker(original, REPRO_AUTO_HTTP_CREATE_SERVER_PATCHED)) return;
+
+    const wrappedCreateServer = function reproPatchedHttpCreateServer(this: any, ...args: any[]) {
+        const cfg = reproAutoMiddlewareConfig;
+        if (cfg) {
+            const listenerIndex =
+                typeof args[0] === 'function'
+                    ? 0
+                    : typeof args[1] === 'function'
+                        ? 1
+                        : -1;
+            if (listenerIndex >= 0) {
+                args[listenerIndex] = wrapHttpRequestListener(args[listenerIndex], cfg);
+            }
+        }
+        const server = original.apply(this, args);
+        patchHttpServerRequestListenerMethods(server);
+        return server;
+    };
+    setMarker(wrappedCreateServer, REPRO_AUTO_HTTP_CREATE_SERVER_PATCHED);
+    httpModule.createServer = wrappedCreateServer;
+}
+
+function patchHttpServerAutoAttach(): void {
+    patchHttpCreateServerFromModuleExports(requireOptionalHostModule('node:http') ?? requireOptionalHostModule('http'));
+    patchHttpCreateServerFromModuleExports(requireOptionalHostModule('node:https') ?? requireOptionalHostModule('https'));
+}
+
 function patchKnownFrameworkModules(): void {
     const nestModules = new Set<any>();
     const resolvedNest = requireOptionalHostModule('@nestjs/core');
@@ -9742,6 +9920,7 @@ export async function initRepro(cfg: ReproInitConfig): Promise<void> {
     shareRuntimePrivacyState(reproAutoMiddlewareConfig, integrationCfg);
 
     installFrameworkRequireHook();
+    patchHttpServerAutoAttach();
     patchKnownFrameworkModules();
 
     patchHttpClients({
@@ -9752,6 +9931,7 @@ export async function initRepro(cfg: ReproInitConfig): Promise<void> {
     patchAmqplib(integrationCfg);
     patchRedis(integrationCfg);
     patchMongoDb(integrationCfg);
+    await installMongoDbImportHook();
     patchSendgridMail(integrationCfg);
     patchMongooseIntegration(reproAutoMiddlewareConfig);
 

package/test/init-auto-http-server.test.js

@@ -0,0 +1,170 @@
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const mongodb = require('mongodb');
+
+const originalNativeMongoInsertOne = mongodb.Collection.prototype.insertOne;
+mongodb.Collection.prototype.insertOne = async function reproFakeNativeMongoInsertOne(doc, options) {
+    assert.equal(options.session.id, 'auto-http-native-session-1');
+    doc._id = doc._id ?? 'subject-auto-http-1';
+    return { acknowledged: true, insertedId: doc._id };
+};
+
+const { initRepro, reproMiddleware } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 3000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(25);
+    }
+    assert(predicate(), 'timed out waiting for expected condition');
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+function backendRequests(posts, sessionId) {
+    return flattenEvents(posts).filter((event) => {
+        return event?.event_type === 'backend_request' && event?.session_id === sessionId;
+    });
+}
+
+function dbChanges(posts, sessionId) {
+    return flattenEvents(posts)
+        .filter((event) => event?.event_type === 'db_change' && event?.session_id === sessionId)
+        .flatMap((event) => Array.isArray(event?.payload?.db) ? event.payload.db : []);
+}
+
+async function listen(server) {
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    return server.address().port;
+}
+
+async function close(server) {
+    await new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+    });
+}
+
+async function request(port, sessionId, actionId) {
+    await new Promise((resolve, reject) => {
+        const req = http.request({
+            host: '127.0.0.1',
+            port,
+            path: '/subjects',
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'x-bug-session-id': sessionId,
+                'x-bug-action-id': actionId,
+                'x-bug-request-start': String(Date.now()),
+            },
+        }, (res) => {
+            res.resume();
+            res.on('end', resolve);
+        });
+        req.on('error', reject);
+        req.end(JSON.stringify({ ok: true }));
+    });
+}
+
+async function main() {
+    const capturedBodies = [];
+    const originalFetch = global.fetch;
+    global.fetch = async (_url, init = {}) => {
+        capturedBodies.push(JSON.parse(String(init.body || '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    const cfg = {
+        tenantId: 'TENANT_test',
+        appId: 'APP_test',
+        appSecret: 'secret',
+        appName: 'auto-http-test',
+        serviceName: 'Auto HTTP Test',
+        captureHeaders: false,
+        privacy: { environment: 'dev', captureRaw: true },
+        ingestBase: 'http://127.0.0.1:65535',
+    };
+
+    let autoServer;
+    let doubleServer;
+    try {
+        await initRepro(cfg);
+
+        const subjectsCollection = new mongodb.MongoClient('mongodb://127.0.0.1:27017/clinical')
+            .db('clinical')
+            .collection('subjects');
+
+        autoServer = http.createServer(async (_req, res) => {
+            await subjectsCollection.insertOne(
+                { subjectNumber: '10013038', status: 'screened' },
+                {
+                    session: {
+                        id: 'auto-http-native-session-1',
+                        hasEnded: false,
+                        inTransaction: () => true,
+                    },
+                },
+            );
+            res.setHeader('content-type', 'application/json');
+            res.end(JSON.stringify({ ok: true, mode: 'auto' }));
+        });
+        const autoPort = await listen(autoServer);
+        await request(autoPort, 'S_auto_http_only', 'A_auto_http_only');
+        await waitFor(() => backendRequests(capturedBodies, 'S_auto_http_only').length === 1);
+        await waitFor(() => dbChanges(capturedBodies, 'S_auto_http_only').length === 1);
+        assert.equal(backendRequests(capturedBodies, 'S_auto_http_only').length, 1);
+        const [nativeMongoChange] = dbChanges(capturedBodies, 'S_auto_http_only');
+        assert.equal(nativeMongoChange.type, 'mongo');
+        assert.equal(nativeMongoChange.collection, 'subjects');
+        assert.equal(nativeMongoChange.op, 'insertOne');
+        assert.equal(nativeMongoChange.pk._id, 'subject-auto-http-1');
+        assert.equal(nativeMongoChange.query.driver, 'mongodb');
+        assert.equal(nativeMongoChange.query.db, 'clinical');
+        assert.equal(nativeMongoChange.query.doc.subjectNumber, '10013038');
+        assert.equal(nativeMongoChange.query.options.session.__kind, 'mongodb_client_session');
+        assert.equal(nativeMongoChange.query.options.session.id, 'auto-http-native-session-1');
+        assert.equal(nativeMongoChange.after.subjectNumber, '10013038');
+        assert.equal(nativeMongoChange.resultMeta.insertedId, 'subject-auto-http-1');
+
+        const manual = reproMiddleware(cfg);
+        doubleServer = http.createServer((req, res) => {
+            manual(req, res, () => {
+                res.setHeader('content-type', 'application/json');
+                res.end(JSON.stringify({ ok: true, mode: 'manual-too' }));
+            });
+        });
+        const doublePort = await listen(doubleServer);
+        await request(doublePort, 'S_auto_http_no_duplicate', 'A_auto_http_no_duplicate');
+        await waitFor(() => backendRequests(capturedBodies, 'S_auto_http_no_duplicate').length === 1);
+        assert.equal(backendRequests(capturedBodies, 'S_auto_http_no_duplicate').length, 1);
+
+        console.log('initRepro auto HTTP server middleware OK');
+    } finally {
+        if (autoServer?.listening) await close(autoServer);
+        if (doubleServer?.listening) await close(doubleServer);
+        await flushIngestQueue();
+        mongodb.Collection.prototype.insertOne = originalNativeMongoInsertOne;
+        global.fetch = originalFetch;
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/mongodb-esm-import-hook.test.js

@@ -0,0 +1,207 @@
+process.env.REPRO_INGEST_REQUEST_TIMEOUT_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '25';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('assert');
+const { EventEmitter } = require('events');
+const { pathToFileURL } = require('url');
+const { join } = require('path');
+const { mkdtempSync, mkdirSync, rmSync, writeFileSync } = require('fs');
+const { tmpdir } = require('os');
+const { initRepro, reproMiddleware, __reproTestHooks } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 3000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(20);
+    }
+    assert(predicate(), 'timed out waiting for expected ingest payload');
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+function dbChanges(events) {
+    return events
+        .filter((event) => event.event_type === 'db_change')
+        .flatMap((event) => Array.isArray(event.payload?.db) ? event.payload.db : []);
+}
+
+function makeReqRes() {
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/native-mongodb-esm';
+    req.originalUrl = '/native-mongodb-esm';
+    req.headers = {
+        'x-bug-session-id': 'S_mongo_esm',
+        'x-bug-action-id': 'A_mongo_esm',
+    };
+    req.query = {};
+    req.params = {};
+    req.body = undefined;
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => undefined;
+    res.getHeaders = () => ({});
+    res.write = () => true;
+    res.end = function end() {
+        this.emit('finish');
+        return this;
+    };
+
+    return { req, res };
+}
+
+function createEsmMongoFixture() {
+    const root = mkdtempSync(join(tmpdir(), 'repro-node-sdk-esm-mongodb-'));
+    const packageDir = join(root, 'node_modules', 'mongodb');
+    mkdirSync(packageDir, { recursive: true });
+    writeFileSync(join(packageDir, 'package.json'), JSON.stringify({
+        name: 'mongodb',
+        version: '99.0.0-repro-fixture',
+        type: 'module',
+        exports: './index.mjs',
+    }, null, 2));
+    writeFileSync(join(packageDir, 'index.mjs'), `
+export class Collection {
+  constructor(dbName, collectionName) {
+    this.dbName = dbName;
+    this.collectionName = collectionName;
+  }
+
+  async insertOne(doc, options) {
+    if (options?.session?.id !== 'esm-native-session-1') {
+      throw new Error(\`unexpected session \${options?.session?.id}\`);
+    }
+    doc._id = doc._id ?? 'subject-esm-1';
+    return { acknowledged: true, insertedId: doc._id };
+  }
+}
+
+export class Db {
+  constructor(dbName) {
+    this.databaseName = dbName;
+  }
+
+  collection(collectionName) {
+    return new Collection(this.databaseName, collectionName);
+  }
+}
+
+export class MongoClient {
+  constructor(uri) {
+    this.uri = uri;
+  }
+
+  db(dbName) {
+    return new Db(dbName);
+  }
+}
+`);
+    const appFile = join(root, 'app.mjs');
+    writeFileSync(appFile, `
+import { MongoClient } from 'mongodb';
+
+const dbClient = new MongoClient('mongodb://127.0.0.1:27017/clinical');
+
+export async function insertSubject() {
+  const subjectsCollection = dbClient.db('clinical').collection('subjects');
+  return subjectsCollection.insertOne(
+    { subjectNumber: '10013038', status: 'screened' },
+    {
+      session: {
+        id: 'esm-native-session-1',
+        hasEnded: false,
+        inTransaction: () => true,
+      },
+    },
+  );
+}
+`);
+    return { root, appFile };
+}
+
+async function main() {
+    const capturedBodies = [];
+    const originalFetch = global.fetch;
+    let fixtureRoot = null;
+    global.fetch = async (_url, init) => {
+        capturedBodies.push(JSON.parse(String(init?.body ?? '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    try {
+        const cfg = {
+            tenantId: 'TENANT_test',
+            appId: 'APP_test',
+            appSecret: 'secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev', captureRaw: true },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+        await initRepro(cfg);
+
+        const fixture = createEsmMongoFixture();
+        fixtureRoot = fixture.root;
+        const fixtureUrl = pathToFileURL(fixture.appFile).href;
+        const { insertSubject } = await import(`${fixtureUrl}?run=${Date.now()}`);
+
+        const middleware = reproMiddleware(cfg);
+        const { req, res } = makeReqRes();
+        await new Promise((resolve, reject) => {
+            middleware(req, res, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                Promise.resolve(insertSubject()).then(resolve, reject);
+            });
+        });
+        res.end();
+
+        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length === 1);
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+
+        const [change] = dbChanges(flattenEvents(capturedBodies));
+        assert.strictEqual(change.type, 'mongo');
+        assert.strictEqual(change.collection, 'subjects');
+        assert.strictEqual(change.op, 'insertOne');
+        assert.strictEqual(change.pk._id, 'subject-esm-1');
+        assert.strictEqual(change.query.driver, 'mongodb');
+        assert.strictEqual(change.query.db, 'clinical');
+        assert.strictEqual(change.query.doc.subjectNumber, '10013038');
+        assert.strictEqual(change.query.options.session.__kind, 'mongodb_client_session');
+        assert.strictEqual(change.query.options.session.id, 'esm-native-session-1');
+        assert.strictEqual(change.after.subjectNumber, '10013038');
+        assert.strictEqual(change.resultMeta.insertedId, 'subject-esm-1');
+
+        console.log('mongodb esm import hook OK');
+    } finally {
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+        if (fixtureRoot) {
+            try { rmSync(fixtureRoot, { recursive: true, force: true }); } catch {}
+        }
+        global.fetch = originalFetch;
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});