@reproapp/node-sdk 0.0.26 → 0.0.27

package/src/index.ts

@@ -1154,6 +1154,13 @@ type Ctx = {
     maskReq?: MaskRequestContext;
     privacyTasks?: Set<Promise<void>>;
     captureScope?: RequestCaptureScopeState;
+    nativeMongoSuppressions?: NativeMongoSuppression[];
+};
+
+type NativeMongoSuppression = {
+    collection?: string | null;
+    ops?: Set<string>;
+    startedAt: number;
 };
 
 type RequestCaptureScopeState = {
@@ -1213,6 +1220,54 @@ function buildRequestCaptureManifestPayload(
 const als = new AsyncLocalStorage<Ctx>();
 const getCtx = () => als.getStore() || {};
 
+function normalizeNativeMongoSuppressionOp(op: string | null | undefined): string {
+    return String(op ?? '').trim();
+}
+
+function pushNativeMongoSuppression(collection: any, ops?: string[] | readonly string[]): NativeMongoSuppression | null {
+    const store = als.getStore();
+    if (!store) return null;
+    const normalizedOps = Array.isArray(ops)
+        ? ops.map(normalizeNativeMongoSuppressionOp).filter(Boolean)
+        : [];
+    const token: NativeMongoSuppression = {
+        collection: collection == null ? null : String(collection),
+        ops: normalizedOps.length ? new Set(normalizedOps) : undefined,
+        startedAt: Date.now(),
+    };
+    if (!Array.isArray(store.nativeMongoSuppressions)) {
+        store.nativeMongoSuppressions = [];
+    }
+    store.nativeMongoSuppressions.push(token);
+    return token;
+}
+
+function popNativeMongoSuppression(token: NativeMongoSuppression | null | undefined): void {
+    if (!token) return;
+    const store = als.getStore();
+    const suppressions = store?.nativeMongoSuppressions;
+    if (!Array.isArray(suppressions) || suppressions.length === 0) return;
+    const index = suppressions.indexOf(token);
+    if (index >= 0) {
+        suppressions.splice(index, 1);
+    }
+}
+
+function isNativeMongoSuppressed(collection: any, op: string): boolean {
+    const suppressions = (getCtx() as Ctx).nativeMongoSuppressions;
+    if (!Array.isArray(suppressions) || suppressions.length === 0) return false;
+    const normalizedCollection = collection == null ? null : String(collection);
+    const normalizedOp = normalizeNativeMongoSuppressionOp(op);
+    const now = Date.now();
+    for (const token of suppressions) {
+        if (!token || now - token.startedAt > 60000) continue;
+        if (token.collection && normalizedCollection && token.collection !== normalizedCollection) continue;
+        if (token.ops && token.ops.size > 0 && !token.ops.has(normalizedOp)) continue;
+        return true;
+    }
+    return false;
+}
+
 function currentClockSkewMs(): number {
     const store = als.getStore();
     const skew = store?.clockSkewMs;
@@ -5424,6 +5479,15 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
 //   - ONLY schema middleware (pre/post) for specific ops
 //   - keeps your existing doc-diff hooks
 // ===================================================================
+function nativeMongoOpsForMongooseOp(op: string): string[] {
+    if (op === 'findByIdAndUpdate') return ['findOneAndUpdate'];
+    if (op === 'findByIdAndDelete' || op === 'findByIdAndRemove' || op === 'findOneAndRemove') {
+        return ['findOneAndDelete'];
+    }
+    if (op === 'findByIdAndReplace') return ['findOneAndReplace'];
+    return [op];
+}
+
 export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
     return function (schema: Schema) {
         // -------- pre/post save (unchanged) --------
@@ -5441,6 +5505,10 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                     ? (this as any).modifiedPaths()
                     : [],
             };
+            (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression(
+                (this as any).__repro_meta.collection,
+                this.isNew ? ['insertOne'] : ['updateOne', 'replaceOne'],
+            );
             next();
         });
 
@@ -5475,6 +5543,12 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                 t: alignTimestamp(meta.t0 ?? Date.now()),
                 spanContext,
             });
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+        });
+
+        schema.post('save', { document: true }, function (error: any, _doc: any, next: Function) {
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+            next(error);
         });
 
         // -------- findOneAndUpdate capture (unchanged) --------
@@ -5489,6 +5563,10 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                 (this as any).__repro_spanContext = captureSpanContextFromTracer(this);
                 (this as any).__repro_filter = filter;
                 (this as any).__repro_update = this.getUpdate?.() ?? (this as any)._update ?? undefined;
+                (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression(
+                    (this as any).__repro_collection,
+                    ['findOneAndUpdate'],
+                );
             } catch {}
             next();
         });
@@ -5518,8 +5596,14 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                 t: alignTimestamp((this as any).__repro_t0 ?? Date.now()),
                 spanContext,
             });
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
         });
 
+        schema.post<Query<any, any>>('findOneAndUpdate', function (this: any, error: any, _res: any, next: Function) {
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+            next(error);
+        } as any);
+
         // -------- deleteOne capture (unchanged) --------
         schema.pre<Query<any, any>>('deleteOne', { document: false, query: true }, function (next) {
             const { sid, aid } = getCtx(); if (!sid || !aid) return next();
@@ -5529,6 +5613,10 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                 (this as any).__repro_collection = resolveCollectionOrWarn(this, 'query');
                 (this as any).__repro_filter = filter;
                 (this as any).__repro_spanContext = captureSpanContextFromTracer(this);
+                (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression(
+                    (this as any).__repro_collection,
+                    ['deleteOne'],
+                );
             } catch {}
             next();
         });
@@ -5550,8 +5638,14 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                 t: alignTimestamp((this as any).__repro_t0 ?? Date.now()),
                 spanContext,
             });
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
         });
 
+        schema.post<Query<any, any>>('deleteOne', { document: false, query: true }, function (this: any, error: any, _res: any, next: Function) {
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+            next(error);
+        } as any);
+
         // -------- NON-intrusive generic query telemetry via schema hooks -------
         const READ_OPS = [
             'find',
@@ -5593,6 +5687,10 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                         rawProjection,
                         rawOptions,
                     };
+                    (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression(
+                        (this as any).__repro_qmeta.collection,
+                        nativeMongoOpsForMongooseOp(op),
+                    );
                 } catch {
                     (this as any).__repro_qmeta = {
                         t0: Date.now(),
@@ -5600,6 +5698,10 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                         op,
                         spanContext: captureSpanContextFromTracer(this),
                     };
+                    (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression(
+                        'unknown',
+                        nativeMongoOpsForMongooseOp(op),
+                    );
                 }
                 next();
             });
@@ -5625,7 +5727,13 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                     t: alignedNow(),
                     spanContext,
                 });
+                popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
             });
+
+            schema.post(op as any, function (this: any, error: any, _res: any, next: Function) {
+                popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+                next(error);
+            } as any);
         }
 
         READ_OPS.forEach(attachQueryHooks);
@@ -5641,12 +5749,17 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                     rawDocs,
                     spanContext: captureSpanContextFromTracer(this),
                 };
+                (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression(
+                    (this as any).__repro_insert_meta.collection,
+                    ['insertMany'],
+                );
             } catch {
                 (this as any).__repro_insert_meta = {
                     t0: Date.now(),
                     collection: 'unknown',
                     spanContext: captureSpanContextFromTracer(this),
                 };
+                (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression('unknown', ['insertMany']);
             }
             next();
         } as any);
@@ -5666,6 +5779,12 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                 t: alignedNow(),
                 spanContext,
             });
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+        } as any);
+
+        schema.post<any>('insertMany' as any, { document: false, query: false } as any, function (this: any, error: any, _res: any, next: Function) {
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+            next(error);
         } as any);
 
         schema.pre<any>('bulkWrite' as any, { document: false, query: false } as any, function (this: any, next: Function, ops?: any[]) {
@@ -5677,12 +5796,17 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                     rawOps,
                     spanContext: captureSpanContextFromTracer(this),
                 };
+                (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression(
+                    (this as any).__repro_bulk_meta.collection,
+                    ['bulkWrite'],
+                );
             } catch {
                 (this as any).__repro_bulk_meta = {
                     t0: Date.now(),
                     collection: 'unknown',
                     spanContext: captureSpanContextFromTracer(this),
                 };
+                (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression('unknown', ['bulkWrite']);
             }
             next();
         } as any);
@@ -5702,6 +5826,12 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                 t: alignedNow(),
                 spanContext,
             });
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+        } as any);
+
+        schema.post<any>('bulkWrite' as any, { document: false, query: false } as any, function (this: any, error: any, _res: any, next: Function) {
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+            next(error);
         } as any);
 
         // Aggregate middleware (non-intrusive)
@@ -5718,6 +5848,10 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                     spanContext: captureSpanContextFromTracer(this),
                     rawPipeline,
                 };
+                (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression(
+                    (this as any).__repro_aggmeta.collection,
+                    ['aggregate'],
+                );
             } catch {
                 (this as any).__repro_aggmeta = {
                     t0: Date.now(),
@@ -5725,6 +5859,7 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                     pipeline: undefined,
                     spanContext: captureSpanContextFromTracer(this),
                 };
+                (this as any).__repro_native_mongo_suppression = pushNativeMongoSuppression('unknown', ['aggregate']);
             }
             next();
         });
@@ -5745,7 +5880,13 @@ export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
                 t: alignedNow(),
                 spanContext,
             });
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
         });
+
+        schema.post('aggregate', function (this: any, error: any, _res: any, next: Function) {
+            popNativeMongoSuppression((this as any).__repro_native_mongo_suppression);
+            next(error);
+        } as any);
     };
 }
 
@@ -5771,9 +5912,23 @@ function summarizeQueryResult(op: string, res: any) {
         return summary;
     }
 
+    if (op === 'insertOne') {
+        const summary: Record<string, any> = {
+            insertedId: res?.insertedId ?? undefined,
+            acknowledged: res?.acknowledged ?? undefined,
+        };
+        if (typeof resultPreview !== 'undefined') summary.result = resultPreview;
+        return summary;
+    }
+
     if (op === 'insertMany') {
         const summary: Record<string, any> = {};
         if (Array.isArray(res)) summary.inserted = res.length;
+        else {
+            summary.inserted = res?.insertedCount ?? undefined;
+            summary.insertedIds = res?.insertedIds ?? undefined;
+            summary.acknowledged = res?.acknowledged ?? undefined;
+        }
         if (typeof resultPreview !== 'undefined') summary.result = resultPreview;
         return summary;
     }
@@ -8588,6 +8743,502 @@ export function patchRedis(cfg: RedisPatchConfig) {
     }
 }
 
+// ===================================================================
+// Native MongoDB driver integration
+// ===================================================================
+export type MongoDbPatchConfig = ReproMiddlewareConfig & {
+    resolveContext?: () => { sid?: string; aid?: string } | undefined;
+};
+
+const mongoDbPatchConfigs: MongoDbPatchConfig[] = [];
+let mongoDbRequireHookInstalled = false;
+
+const MONGODB_PROMISE_OPS = [
+    'insertOne',
+    'insertMany',
+    'updateOne',
+    'updateMany',
+    'replaceOne',
+    'deleteOne',
+    'deleteMany',
+    'findOne',
+    'countDocuments',
+    'estimatedDocumentCount',
+    'distinct',
+    'bulkWrite',
+    'findOneAndUpdate',
+    'findOneAndDelete',
+    'findOneAndReplace',
+] as const;
+
+const MONGODB_CURSOR_OPS = ['find', 'aggregate'] as const;
+const MONGODB_CURSOR_TERMINALS = ['toArray', 'next', 'forEach'] as const;
+
+function resolveMongoDbRuntimeContext(cfg: MongoDbPatchConfig) {
+    const ctx = getCtx();
+    const fallback = cfg.resolveContext?.() ?? {};
+    return {
+        ctx,
+        sid: ctx.sid ?? fallback.sid ?? null,
+        aid: ctx.aid ?? fallback.aid ?? null,
+    };
+}
+
+function resolveMongoCollectionName(collection: any): string {
+    const candidates = [
+        collection?.collectionName,
+        collection?.namespace?.collection,
+        collection?.s?.namespace?.collection,
+        collection?.s?.namespace?.collectionName,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim()) return candidate;
+    }
+
+    const namespace =
+        typeof collection?.namespace === 'string'
+            ? collection.namespace
+            : typeof collection?.s?.namespace === 'string'
+                ? collection.s.namespace
+                : typeof collection?.namespace?.toString === 'function'
+                    ? collection.namespace.toString()
+                    : typeof collection?.s?.namespace?.toString === 'function'
+                        ? collection.s.namespace.toString()
+                        : null;
+    if (namespace && namespace.includes('.')) {
+        return namespace.slice(namespace.indexOf('.') + 1) || namespace;
+    }
+    return namespace || 'unknown';
+}
+
+function resolveMongoDbName(collection: any): string | undefined {
+    const candidates = [
+        collection?.dbName,
+        collection?.db?.databaseName,
+        collection?.s?.db?.databaseName,
+        collection?.namespace?.db,
+        collection?.s?.namespace?.db,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim()) return candidate;
+    }
+    const namespace =
+        typeof collection?.namespace === 'string'
+            ? collection.namespace
+            : typeof collection?.s?.namespace === 'string'
+                ? collection.s.namespace
+                : null;
+    if (namespace && namespace.includes('.')) {
+        return namespace.slice(0, namespace.indexOf('.')) || undefined;
+    }
+    return undefined;
+}
+
+function summarizeMongoSession(session: any): any {
+    if (!session || typeof session !== 'object') return session;
+    let inTransaction: any = undefined;
+    try {
+        inTransaction = typeof session.inTransaction === 'function' ? session.inTransaction() : undefined;
+    } catch {}
+    return {
+        __kind: 'mongodb_client_session',
+        id: session.id ?? session.serverSession?.id ?? undefined,
+        hasEnded: session.hasEnded ?? undefined,
+        inTransaction,
+    };
+}
+
+function normalizeMongoDriverOptions(options: any): any {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) return options;
+    const normalized: Record<string, any> = {};
+    for (const key of Object.keys(options)) {
+        normalized[key] = key === 'session'
+            ? summarizeMongoSession(options[key])
+            : options[key];
+    }
+    return normalized;
+}
+
+function summarizeMongoError(error: any): Record<string, any> {
+    return {
+        name: error?.name ?? undefined,
+        message: error?.message ?? String(error),
+        code: error?.code ?? undefined,
+        codeName: error?.codeName ?? undefined,
+    };
+}
+
+function extractMongoPkFromFilter(filter: any): any {
+    if (filter && typeof filter === 'object' && Object.prototype.hasOwnProperty.call(filter, '_id')) {
+        return { _id: filter._id };
+    }
+    return undefined;
+}
+
+function extractMongoPkFromDoc(doc: any, result?: any): any {
+    const id = doc && typeof doc === 'object' ? doc._id : undefined;
+    const insertedId = result?.insertedId;
+    if (id !== undefined) return { _id: id };
+    if (insertedId !== undefined) return { _id: insertedId };
+    return undefined;
+}
+
+function buildMongoQueryPayload(op: string, args: any[], dbName?: string): any {
+    const withDriver = (payload: Record<string, any>) => ({
+        driver: 'mongodb',
+        db: dbName,
+        ...payload,
+    });
+
+    if (op === 'insertOne') {
+        return withDriver({ doc: args[0], options: normalizeMongoDriverOptions(args[1]) });
+    }
+    if (op === 'insertMany') {
+        return withDriver({ docs: args[0], options: normalizeMongoDriverOptions(args[1]) });
+    }
+    if (op === 'updateOne' || op === 'updateMany') {
+        return withDriver({ filter: args[0], update: args[1], options: normalizeMongoDriverOptions(args[2]) });
+    }
+    if (op === 'replaceOne') {
+        return withDriver({ filter: args[0], replacement: args[1], options: normalizeMongoDriverOptions(args[2]) });
+    }
+    if (op === 'deleteOne' || op === 'deleteMany') {
+        return withDriver({ filter: args[0], options: normalizeMongoDriverOptions(args[1]) });
+    }
+    if (op === 'findOne' || op === 'find' || op === 'countDocuments') {
+        return withDriver({ filter: args[0], options: normalizeMongoDriverOptions(args[1]) });
+    }
+    if (op === 'estimatedDocumentCount') {
+        return withDriver({ options: normalizeMongoDriverOptions(args[0]) });
+    }
+    if (op === 'distinct') {
+        return withDriver({ key: args[0], filter: args[1], options: normalizeMongoDriverOptions(args[2]) });
+    }
+    if (op === 'bulkWrite') {
+        return withDriver({ ops: args[0], options: normalizeMongoDriverOptions(args[1]) });
+    }
+    if (op === 'findOneAndUpdate') {
+        return withDriver({ filter: args[0], update: args[1], options: normalizeMongoDriverOptions(args[2]) });
+    }
+    if (op === 'findOneAndReplace') {
+        return withDriver({ filter: args[0], replacement: args[1], options: normalizeMongoDriverOptions(args[2]) });
+    }
+    if (op === 'findOneAndDelete') {
+        return withDriver({ filter: args[0], options: normalizeMongoDriverOptions(args[1]) });
+    }
+    if (op === 'aggregate') {
+        return withDriver({ pipeline: args[0], options: normalizeMongoDriverOptions(args[1]) });
+    }
+    return withDriver({ args });
+}
+
+function buildMongoPk(op: string, args: any[], result?: any): any {
+    if (op === 'insertOne') return extractMongoPkFromDoc(args[0], result);
+    if (
+        op === 'updateOne' ||
+        op === 'replaceOne' ||
+        op === 'deleteOne' ||
+        op === 'findOne' ||
+        op === 'findOneAndUpdate' ||
+        op === 'findOneAndDelete' ||
+        op === 'findOneAndReplace'
+    ) {
+        return extractMongoPkFromFilter(args[0]);
+    }
+    return undefined;
+}
+
+function buildMongoAfter(op: string, args: any[], result?: any): any {
+    if (op === 'insertOne') return args[0] ?? null;
+    if (op === 'insertMany') return args[0] ?? null;
+    if (op === 'findOne' || op === 'findOneAndUpdate' || op === 'findOneAndDelete' || op === 'findOneAndReplace') {
+        return result ?? null;
+    }
+    if (op === 'find' || op === 'aggregate') {
+        return Array.isArray(result) ? result : null;
+    }
+    return null;
+}
+
+function findMongoCallbackIndex(args: any[]): number {
+    for (let i = args.length - 1; i >= 0; i -= 1) {
+        if (typeof args[i] === 'function') return i;
+    }
+    return -1;
+}
+
+function patchMongoCursorInstance(cursor: any, meta: {
+    cfg: MongoDbPatchConfig;
+    sid: string;
+    aid: string | null;
+    collection: string;
+    dbName?: string;
+    op: string;
+    args: any[];
+    spanContext: SpanContext | null;
+}): any {
+    if (!cursor || typeof cursor !== 'object') return cursor;
+    if (cursor.__repro_mongodb_cursor_patched) return cursor;
+    try {
+        Object.defineProperty(cursor, '__repro_mongodb_cursor_patched', {
+            value: true,
+            configurable: true,
+        });
+    } catch {
+        return cursor;
+    }
+
+    for (const methodName of MONGODB_CURSOR_TERMINALS) {
+        const original = cursor[methodName];
+        if (typeof original !== 'function') continue;
+
+        cursor[methodName] = function reproPatchedMongoCursorTerminal(this: any, ...callArgs: any[]) {
+            const t0 = Date.now();
+            let emitted = false;
+            let forEachDocs: any[] | null = null;
+            const emitSuccess = (value: any) => {
+                if (emitted) return;
+                emitted = true;
+                const terminalQueryArgs = [...meta.args] as any[];
+                const queryRaw = buildMongoQueryPayload(meta.op, terminalQueryArgs, meta.dbName);
+                queryRaw.cursorMethod = methodName;
+                emitDbQuery(meta.cfg, meta.sid, meta.aid ?? undefined, {
+                    type: 'mongo',
+                    collection: meta.collection,
+                    op: meta.op,
+                    pk: buildMongoPk(meta.op, meta.args, value),
+                    before: null,
+                    after: buildMongoAfter(meta.op, meta.args, forEachDocs ?? value),
+                    queryRaw,
+                    resultMetaRaw: forEachDocs ?? value,
+                    durMs: Date.now() - t0,
+                    t: alignedNow(),
+                    spanContext: meta.spanContext,
+                });
+            };
+            const emitFailure = (error: any) => {
+                if (emitted) return;
+                emitted = true;
+                const terminalQueryArgs = [...meta.args] as any[];
+                const queryRaw = buildMongoQueryPayload(meta.op, terminalQueryArgs, meta.dbName);
+                queryRaw.cursorMethod = methodName;
+                emitDbQuery(meta.cfg, meta.sid, meta.aid ?? undefined, {
+                    type: 'mongo',
+                    collection: meta.collection,
+                    op: meta.op,
+                    queryRaw,
+                    error: summarizeMongoError(error),
+                    durMs: Date.now() - t0,
+                    t: alignedNow(),
+                    spanContext: meta.spanContext,
+                });
+            };
+
+            const actualArgs = [...callArgs];
+            if (methodName === 'forEach' && typeof actualArgs[0] === 'function') {
+                forEachDocs = [];
+                const originalIterator = actualArgs[0];
+                actualArgs[0] = function reproMongoForEachIterator(this: any, doc: any, ...rest: any[]) {
+                    forEachDocs?.push(doc);
+                    return originalIterator.call(this, doc, ...rest);
+                };
+            }
+
+            try {
+                const value = original.apply(this, actualArgs);
+                if (value && typeof value.then === 'function') {
+                    return value.then(
+                        (resolved: any) => {
+                            emitSuccess(resolved);
+                            return resolved;
+                        },
+                        (err: any) => {
+                            emitFailure(err);
+                            throw err;
+                        },
+                    );
+                }
+                emitSuccess(value);
+                return value;
+            } catch (err) {
+                emitFailure(err);
+                throw err;
+            }
+        };
+    }
+
+    return cursor;
+}
+
+function patchMongoCollectionMethod(proto: any, op: string, cursorOp: boolean, cfg: MongoDbPatchConfig): void {
+    if (!proto) return;
+    const marker = `__repro_mongodb_${op}_patched`;
+    if (proto[marker]) return;
+    const original = proto[op];
+    if (typeof original !== 'function') return;
+    proto[marker] = true;
+
+    proto[op] = function reproPatchedMongoCollectionMethod(this: any, ...args: any[]) {
+        const collection = resolveMongoCollectionName(this);
+        if (isNativeMongoSuppressed(collection, op)) {
+            return original.apply(this, args);
+        }
+
+        const { sid, aid } = resolveMongoDbRuntimeContext(cfg);
+        if (!sid) {
+            return original.apply(this, args);
+        }
+
+        const spanContext = captureSpanContextFromTracer(this);
+        const t0 = Date.now();
+        const dbName = resolveMongoDbName(this);
+        const callbackIndex = cursorOp ? -1 : findMongoCallbackIndex(args);
+        const actualArgs = callbackIndex >= 0 ? [...args] : args;
+        let emitted = false;
+
+        const emitSuccess = (result: any) => {
+            if (emitted) return;
+            emitted = true;
+            emitDbQuery(cfg, sid, aid ?? undefined, {
+                type: 'mongo',
+                collection,
+                op,
+                pk: buildMongoPk(op, args, result),
+                before: null,
+                after: buildMongoAfter(op, args, result),
+                queryRaw: buildMongoQueryPayload(op, args, dbName),
+                resultMetaRaw: result,
+                durMs: Date.now() - t0,
+                t: alignedNow(),
+                spanContext,
+            });
+        };
+        const emitFailure = (error: any) => {
+            if (emitted) return;
+            emitted = true;
+            emitDbQuery(cfg, sid, aid ?? undefined, {
+                type: 'mongo',
+                collection,
+                op,
+                queryRaw: buildMongoQueryPayload(op, args, dbName),
+                error: summarizeMongoError(error),
+                durMs: Date.now() - t0,
+                t: alignedNow(),
+                spanContext,
+            });
+        };
+
+        if (callbackIndex >= 0) {
+            const originalCallback = args[callbackIndex];
+            actualArgs[callbackIndex] = function reproMongoCallback(this: any, err: any, result: any, ...rest: any[]) {
+                if (err) emitFailure(err);
+                else emitSuccess(result);
+                return originalCallback.call(this, err, result, ...rest);
+            };
+        }
+
+        try {
+            const result = original.apply(this, actualArgs);
+            if (cursorOp) {
+                return patchMongoCursorInstance(result, {
+                    cfg,
+                    sid,
+                    aid,
+                    collection,
+                    dbName,
+                    op,
+                    args,
+                    spanContext,
+                });
+            }
+            if (result && typeof result.then === 'function') {
+                return result.then(
+                    (value: any) => {
+                        emitSuccess(value);
+                        return value;
+                    },
+                    (error: any) => {
+                        emitFailure(error);
+                        throw error;
+                    },
+                );
+            }
+            if (callbackIndex < 0) {
+                emitSuccess(result);
+            }
+            return result;
+        } catch (error) {
+            emitFailure(error);
+            throw error;
+        }
+    };
+}
+
+function patchMongoCollectionPrototype(proto: any, cfg: MongoDbPatchConfig): void {
+    if (!proto) return;
+    for (const op of MONGODB_PROMISE_OPS) {
+        patchMongoCollectionMethod(proto, op, false, cfg);
+    }
+    for (const op of MONGODB_CURSOR_OPS) {
+        patchMongoCollectionMethod(proto, op, true, cfg);
+    }
+}
+
+function patchMongoDbFromModuleExports(mongoModule: any, cfg: MongoDbPatchConfig): void {
+    if (!mongoModule) return;
+    const constructors = new Set<any>();
+    const addCtor = (candidate: any) => {
+        if (typeof candidate === 'function' && candidate.prototype) {
+            constructors.add(candidate);
+        }
+    };
+
+    addCtor(mongoModule?.Collection);
+    addCtor(mongoModule?.default?.Collection);
+
+    for (const ctor of constructors) {
+        patchMongoCollectionPrototype(ctor.prototype, cfg);
+    }
+}
+
+function installMongoDbRequireHook(): void {
+    if (mongoDbRequireHookInstalled) return;
+    mongoDbRequireHookInstalled = true;
+
+    try {
+        const rim = requireOptionalHostModule('require-in-the-middle');
+        const Hook = rim?.Hook ?? rim;
+        if (typeof Hook !== 'function') return;
+
+        // eslint-disable-next-line no-new
+        new Hook(['mongodb'], (exports: any) => {
+            for (const cfg of mongoDbPatchConfigs) {
+                patchMongoDbFromModuleExports(exports, cfg);
+            }
+            return exports;
+        });
+    } catch {}
+}
+
+export function patchMongoDb(cfg: MongoDbPatchConfig): void {
+    mongoDbPatchConfigs.push(cfg);
+    installMongoDbRequireHook();
+
+    const mongoModules = new Set<any>();
+    const resolvedMongoModule = requireOptionalHostModule('mongodb');
+    if (resolvedMongoModule) {
+        mongoModules.add(resolvedMongoModule);
+    }
+    for (const loadedMongoModule of getLoadedModuleExportsByPackage('mongodb')) {
+        mongoModules.add(loadedMongoModule);
+    }
+    if (!mongoModules.size) return;
+
+    for (const mongoModule of mongoModules) {
+        patchMongoDbFromModuleExports(mongoModule, cfg);
+    }
+}
+
 // ===================================================================
 // Auto init helpers
 // ===================================================================
@@ -9015,6 +9666,7 @@ export async function initRepro(cfg: ReproInitConfig): Promise<void> {
     patchKafkaJs(integrationCfg);
     patchAmqplib(integrationCfg);
     patchRedis(integrationCfg);
+    patchMongoDb(integrationCfg);
     patchSendgridMail(integrationCfg);
     patchMongooseIntegration(reproAutoMiddlewareConfig);
 
@@ -9066,6 +9718,8 @@ export const __reproTestHooks = {
     patchAmqplibConnectionForTest: patchAmqplibConnection,
     patchAmqplibChannelForTest: patchAmqplibChannel,
     wrapAmqplibConsumeHandlerForTest: wrapAmqplibConsumeHandler,
+    patchMongoDbModuleForTest: patchMongoDbFromModuleExports,
+    patchMongoCollectionPrototypeForTest: patchMongoCollectionPrototype,
     chunkTraceEventsForTransportForTest: chunkTraceEventsForTransport,
     estimateTraceBatchSerializedBytesForTest: estimateTraceBatchSerializedBytes,
     sanitizeTraceValueForPrivacyForTest: sanitizeTraceValueForPrivacy,