@reproapp/node-sdk 0.0.32 → 0.0.34

package/dist/index.js

@@ -824,6 +824,19 @@ const getCtx = () => als.getStore() || {};
 function normalizeNativeMongoSuppressionOp(op) {
     return String(op ?? '').trim();
 }
+const NATIVE_MONGO_WRITE_OPS = new Set([
+    'insertOne',
+    'insertMany',
+    'updateOne',
+    'updateMany',
+    'replaceOne',
+    'deleteOne',
+    'deleteMany',
+    'bulkWrite',
+    'findOneAndUpdate',
+    'findOneAndDelete',
+    'findOneAndReplace',
+]);
 function pushNativeMongoSuppression(collection, ops) {
     const store = als.getStore();
     if (!store)
@@ -869,13 +882,28 @@ function releaseNativeMongoSuppression(target) {
         catch { }
     }
 }
+function isMongooseInternalNativeMongoCall() {
+    let stack = '';
+    try {
+        stack = new Error().stack ?? '';
+    }
+    catch {
+        stack = '';
+    }
+    return stack.includes('/node_modules/mongoose/') ||
+        stack.includes('\\node_modules\\mongoose\\') ||
+        stack.includes('mongoose/lib/');
+}
 function isNativeMongoSuppressed(collection, op) {
     const suppressions = getCtx().nativeMongoSuppressions;
     if (!Array.isArray(suppressions) || suppressions.length === 0)
         return false;
     const normalizedCollection = collection == null ? null : String(collection);
     const normalizedOp = normalizeNativeMongoSuppressionOp(op);
+    if (NATIVE_MONGO_WRITE_OPS.has(normalizedOp))
+        return false;
     const now = Date.now();
+    const matchingTokens = [];
     for (let i = suppressions.length - 1; i >= 0; i -= 1) {
         const token = suppressions[i];
         if (!token || now - token.startedAt > 60000) {
@@ -886,9 +914,17 @@ function isNativeMongoSuppressed(collection, op) {
             continue;
         if (token.ops && token.ops.size > 0 && !token.ops.has(normalizedOp))
             continue;
-        return true;
+        matchingTokens.push(token);
     }
-    return false;
+    if (matchingTokens.length === 0)
+        return false;
+    if (!isMongooseInternalNativeMongoCall()) {
+        return false;
+    }
+    for (const token of matchingTokens) {
+        popNativeMongoSuppression(token);
+    }
+    return true;
 }
 function currentClockSkewMs() {
     const store = als.getStore();
@@ -3878,7 +3914,7 @@ function estimateTraceBatchSerializedBytes(batch, requestRid, actionId, batchInd
 function chunkTraceEventsForTransport(events, requestRid, actionId) {
     if (!Array.isArray(events) || events.length === 0)
         return [];
-    const boundedEvents = events.slice(0, TRACE_MAX_EVENTS_PER_REQUEST);
+    const boundedEvents = boundTraceEventsForTransport(events);
     const countBatches = chunkArray(boundedEvents, TRACE_BATCH_SIZE);
     const sizedBatches = [];
     let current = [];
@@ -3907,6 +3943,13 @@ function chunkTraceEventsForTransport(events, requestRid, actionId) {
     }
     return sizedBatches;
 }
+function boundTraceEventsForTransport(events) {
+    if (events.length <= TRACE_MAX_EVENTS_PER_REQUEST)
+        return events;
+    const headCount = Math.floor(TRACE_MAX_EVENTS_PER_REQUEST / 2);
+    const tailCount = TRACE_MAX_EVENTS_PER_REQUEST - headCount;
+    return events.slice(0, headCount).concat(events.slice(events.length - tailCount));
+}
 function createCapturedValueEntry(params) {
     if (!__FULL_VALUE_CAPTURE_ENABLED)
         return undefined;
@@ -5154,6 +5197,9 @@ function emitDbQuery(cfg, sid, aid, payload) {
     const spanContext = payload?.spanContext ?? captureSpanContextFromTracer();
     if (!shouldCaptureDbSpan(spanContext))
         return;
+    if (ctx.captureScope) {
+        ctx.captureScope.dbChangeCount += 1;
+    }
     const runCtx = {
         sid: ctx.sid,
         aid: ctx.aid,
@@ -5281,9 +5327,6 @@ async function emitDbQueryAsync(cfg, sid, aid, payload) {
                 t: payload.t,
             }]
     });
-    if (enqueued && ctx.captureScope) {
-        ctx.captureScope.dbChangeCount += 1;
-    }
 }
 function buildMinimalUpdate(before, after) {
     const set = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,7 @@
     "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/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 && node test/mongodb-suppression-cleanup.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"
+    "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 && node test/mongodb-mongoose-native-suppression.testcontainers.test.js"
   },
   "peerDependencies": {
     "express": "^5.1.0",

package/src/index.ts

@@ -1227,6 +1227,20 @@ function normalizeNativeMongoSuppressionOp(op: string | null | undefined): strin
     return String(op ?? '').trim();
 }
 
+const NATIVE_MONGO_WRITE_OPS = new Set([
+    'insertOne',
+    'insertMany',
+    'updateOne',
+    'updateMany',
+    'replaceOne',
+    'deleteOne',
+    'deleteMany',
+    'bulkWrite',
+    'findOneAndUpdate',
+    'findOneAndDelete',
+    'findOneAndReplace',
+]);
+
 function pushNativeMongoSuppression(collection: any, ops?: string[] | readonly string[]): NativeMongoSuppression | null {
     const store = als.getStore();
     if (!store) return null;
@@ -1267,12 +1281,26 @@ function releaseNativeMongoSuppression(target: any): void {
     }
 }
 
+function isMongooseInternalNativeMongoCall(): boolean {
+    let stack = '';
+    try {
+        stack = new Error().stack ?? '';
+    } catch {
+        stack = '';
+    }
+    return stack.includes('/node_modules/mongoose/') ||
+        stack.includes('\\node_modules\\mongoose\\') ||
+        stack.includes('mongoose/lib/');
+}
+
 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);
+    if (NATIVE_MONGO_WRITE_OPS.has(normalizedOp)) return false;
     const now = Date.now();
+    const matchingTokens: NativeMongoSuppression[] = [];
     for (let i = suppressions.length - 1; i >= 0; i -= 1) {
         const token = suppressions[i];
         if (!token || now - token.startedAt > 60000) {
@@ -1281,9 +1309,18 @@ function isNativeMongoSuppressed(collection: any, op: string): boolean {
         }
         if (token.collection && normalizedCollection && token.collection !== normalizedCollection) continue;
         if (token.ops && token.ops.size > 0 && !token.ops.has(normalizedOp)) continue;
-        return true;
+        matchingTokens.push(token);
     }
-    return false;
+    if (matchingTokens.length === 0) return false;
+
+    if (!isMongooseInternalNativeMongoCall()) {
+        return false;
+    }
+
+    for (const token of matchingTokens) {
+        popNativeMongoSuppression(token);
+    }
+    return true;
 }
 
 function currentClockSkewMs(): number {
@@ -4605,7 +4642,7 @@ function chunkTraceEventsForTransport(
 ): TraceEventRecord[][] {
     if (!Array.isArray(events) || events.length === 0) return [];
 
-    const boundedEvents = events.slice(0, TRACE_MAX_EVENTS_PER_REQUEST);
+    const boundedEvents = boundTraceEventsForTransport(events);
     const countBatches = chunkArray(boundedEvents, TRACE_BATCH_SIZE);
     const sizedBatches: TraceEventRecord[][] = [];
     let current: TraceEventRecord[] = [];
@@ -4649,6 +4686,13 @@ function chunkTraceEventsForTransport(
     return sizedBatches;
 }
 
+function boundTraceEventsForTransport(events: TraceEventRecord[]): TraceEventRecord[] {
+    if (events.length <= TRACE_MAX_EVENTS_PER_REQUEST) return events;
+    const headCount = Math.floor(TRACE_MAX_EVENTS_PER_REQUEST / 2);
+    const tailCount = TRACE_MAX_EVENTS_PER_REQUEST - headCount;
+    return events.slice(0, headCount).concat(events.slice(events.length - tailCount));
+}
+
 function createCapturedValueEntry(
     params: {
         target:
@@ -6110,6 +6154,9 @@ function emitDbQuery(cfg: any, sid?: string, aid?: string, payload?: any) {
     const ctx = getCtx() as Ctx;
     const spanContext = payload?.spanContext ?? captureSpanContextFromTracer();
     if (!shouldCaptureDbSpan(spanContext)) return;
+    if (ctx.captureScope) {
+        ctx.captureScope.dbChangeCount += 1;
+    }
     const runCtx: Ctx = {
         sid: ctx.sid,
         aid: ctx.aid,
@@ -6236,9 +6283,6 @@ async function emitDbQueryAsync(cfg: any, sid?: string, aid?: string, payload?:
             t: payload.t,
         }]
     });
-    if (enqueued && ctx.captureScope) {
-        ctx.captureScope.dbChangeCount += 1;
-    }
 }
 
 function buildMinimalUpdate(before: any, after: any) {

package/test/mongodb-integration.test.js

@@ -8,6 +8,7 @@ process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
 const assert = require('assert');
 const { EventEmitter } = require('events');
 const mongodb = require('mongodb');
+const mongoose = require('mongoose');
 
 const originalNativeMongoInsertOne = mongodb.Collection.prototype.insertOne;
 
@@ -18,7 +19,7 @@ mongodb.Collection.prototype.insertOne = async function reproFakeNativeMongoInse
 };
 
 const { flushIngestQueue } = require('../dist/ingest/client');
-const { reproMiddleware, __reproTestHooks } = require('../dist');
+const { reproMiddleware, reproMongoosePlugin, __reproTestHooks } = require('../dist');
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
@@ -126,12 +127,90 @@ async function runCapturedRequest(cfg, sessionId, actionId, fn) {
     res.end();
 }
 
+function execPre(hooks, name, context) {
+    return new Promise((resolve, reject) => {
+        hooks.execPre(name, context, [], (error) => (error ? reject(error) : resolve()));
+    });
+}
+
 function dbChanges(events) {
     return events
         .filter((event) => event.event_type === 'db_change')
         .flatMap((event) => Array.isArray(event.payload?.db) ? event.payload.db : []);
 }
 
+function requestCaptureManifests(events) {
+    return events
+        .filter((event) => event.event_type === 'request_capture_manifest')
+        .map((event) => event.payload?.requestCaptureManifest ?? event.payload)
+        .filter(Boolean);
+}
+
+async function testMongooseSuppressionDoesNotHideExplicitNativeInsertOne() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const sessionId = 'S_mongo_mixed_driver_insert';
+        const actionId = 'A_mongo_mixed_driver_insert';
+        const cfg = makeConfig(sessionId, actionId);
+
+        const schema = new mongoose.Schema({ subjectNumber: String, status: String });
+        reproMongoosePlugin(cfg)(schema);
+        const Model = mongoose.model(`ReproMixedNativeMongo${Date.now()}`, schema, 'subjects');
+        const pendingMongooseDoc = new Model({ subjectNumber: 'pre-save', status: 'pending' });
+
+        class FakeCollection {
+            constructor() {
+                this.collectionName = 'subjects';
+                this.dbName = 'clinical';
+            }
+
+            async insertOne(doc, options) {
+                assert.strictEqual(options.session.id, 'native-explicit-session-1');
+                doc._id = doc._id ?? 'subject-explicit-1';
+                return { acknowledged: true, insertedId: doc._id };
+            }
+        }
+
+        __reproTestHooks.patchMongoCollectionPrototypeForTest(FakeCollection.prototype, cfg);
+        const subjectsCollection = new FakeCollection();
+
+        await runCapturedRequest(cfg, sessionId, actionId, async () => {
+            await execPre(schema.s.hooks, 'save', pendingMongooseDoc);
+            assert.strictEqual(__reproTestHooks.getNativeMongoSuppressionCountForTest(), 1);
+
+            const result = await subjectsCollection.insertOne(
+                { subjectNumber: '10013038', status: 'screened' },
+                {
+                    session: {
+                        id: 'native-explicit-session-1',
+                        hasEnded: false,
+                        inTransaction: () => true,
+                    },
+                },
+            );
+            assert.deepStrictEqual(result, { acknowledged: true, insertedId: 'subject-explicit-1' });
+        });
+
+        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length === 1);
+        await waitFor(() => requestCaptureManifests(flattenEvents(capturedBodies)).length === 1);
+        await drainSdk();
+
+        const [change] = dbChanges(flattenEvents(capturedBodies));
+        const [manifest] = requestCaptureManifests(flattenEvents(capturedBodies));
+        assert.strictEqual(change.type, 'mongo');
+        assert.strictEqual(change.collection, 'subjects');
+        assert.strictEqual(change.op, 'insertOne');
+        assert.strictEqual(change.pk._id, 'subject-explicit-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, 'native-explicit-session-1');
+        assert.strictEqual(change.after.subjectNumber, '10013038');
+        assert.strictEqual(manifest.expected.dbChange, 1);
+    });
+}
+
 async function testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne() {
     await withCapturedFetch(async (capturedBodies) => {
         __reproTestHooks.resetSdkBackgroundQueuesForTest();
@@ -452,6 +531,7 @@ async function testNativeOperationFailureIsCapturedAndRethrown() {
 }
 
 (async () => {
+    await testMongooseSuppressionDoesNotHideExplicitNativeInsertOne();
     await testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne();
     await testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport();
     await testNativeInsertOneIsCaptured();

package/test/mongodb-mongoose-native-suppression.testcontainers.test.js

@@ -0,0 +1,178 @@
+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 mongoose = require('mongoose');
+const { GenericContainer, Wait } = require('testcontainers');
+
+const { flushIngestQueue } = require('../dist/ingest/client');
+const { reproMiddleware, reproMongoosePlugin, __reproTestHooks } = require('../dist');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(25);
+    }
+    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 requestCaptureManifests(events) {
+    return events
+        .filter((event) => event.event_type === 'request_capture_manifest')
+        .map((event) => event.payload?.requestCaptureManifest ?? event.payload)
+        .filter(Boolean);
+}
+
+function makeReqRes(sessionId, actionId) {
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/subjects';
+    req.originalUrl = '/subjects';
+    req.headers = {
+        'x-bug-session-id': sessionId,
+        'x-bug-action-id': actionId,
+    };
+    req.query = {};
+    req.params = {};
+
+    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 };
+}
+
+async function runCapturedRequest(cfg, sessionId, actionId, fn) {
+    const middleware = reproMiddleware(cfg);
+    const { req, res } = makeReqRes(sessionId, actionId);
+    await new Promise((resolve, reject) => {
+        middleware(req, res, (err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            Promise.resolve().then(fn).then(resolve, reject);
+        });
+    });
+    res.end();
+}
+
+async function startMongo() {
+    if (process.env.REPRO_MONGO_TEST_URI) {
+        return {
+            uri: process.env.REPRO_MONGO_TEST_URI,
+            stop: async () => {},
+        };
+    }
+
+    const container = await new GenericContainer('mongo:7')
+        .withExposedPorts(27017)
+        .withTmpFs({ '/data/db': 'rw,noexec,nosuid,size=1g' })
+        .withCommand(['mongod', '--bind_ip_all', '--setParameter', 'diagnosticDataCollectionEnabled=false'])
+        .withWaitStrategy(Wait.forListeningPorts())
+        .start();
+    return {
+        uri: `mongodb://${container.getHost()}:${container.getMappedPort(27017)}/repro_mongoose_native_suppression`,
+        stop: () => container.stop(),
+    };
+}
+
+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}',
+        };
+    };
+
+    let container;
+    let connection;
+    try {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        container = await startMongo();
+        connection = await mongoose.createConnection(container.uri).asPromise();
+
+        const cfg = {
+            tenantId: 'TENANT_test',
+            appId: 'APP_test',
+            appSecret: 'secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev', captureRaw: true },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+
+        const schema = new mongoose.Schema({ subjectNumber: String, status: String });
+        reproMongoosePlugin(cfg)(schema);
+        const Subject = connection.model('Subject', schema, 'subjects');
+
+        await runCapturedRequest(cfg, 'S_mongoose_native_suppression', 'A_mongoose_native_suppression', async () => {
+            await Subject.create({ subjectNumber: '10013038', status: 'screened' });
+        });
+
+        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length >= 2);
+        await waitFor(() => requestCaptureManifests(flattenEvents(capturedBodies)).length === 1);
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+
+        const changes = dbChanges(flattenEvents(capturedBodies));
+        const manifest = requestCaptureManifests(flattenEvents(capturedBodies))[0];
+        const mongooseWrite = changes.find((change) => (
+            change.type === 'mongo' &&
+            change.collection === 'subjects' &&
+            change.op === 'insert' &&
+            change.after?.subjectNumber === '10013038'
+        ));
+        const nativeWrite = changes.find((change) => (
+            change.type === 'mongo' &&
+            change.collection === 'subjects' &&
+            change.op === 'insertOne' &&
+            change.query?.driver === 'mongodb' &&
+            change.after?.subjectNumber === '10013038'
+        ));
+        assert.ok(mongooseWrite, 'expected mongoose-level insert evidence');
+        assert.ok(nativeWrite, 'expected native mongodb insertOne evidence');
+        assert.ok(manifest.expected.dbChange >= 2);
+
+        console.log('mongodb mongoose native suppression testcontainers OK');
+    } finally {
+        await __reproTestHooks.drainSdkBackgroundQueueForTest().catch(() => {});
+        await flushIngestQueue().catch(() => {});
+        global.fetch = originalFetch;
+        if (connection) await connection.close().catch(() => {});
+        if (container) await container.stop().catch(() => {});
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/trace-batch-size.test.js

@@ -66,6 +66,11 @@ function main() {
         cappedEventCount <= 1000,
         `expected trace transport to cap events per request, got ${cappedEventCount}`,
     );
+    const cappedEvents = cappedBatches.flat();
+    assert.strictEqual(cappedEvents[0].fn, 'fn0');
+    assert.strictEqual(cappedEvents[499].fn, 'fn499');
+    assert.strictEqual(cappedEvents[500].fn, 'fn1000');
+    assert.strictEqual(cappedEvents[cappedEvents.length - 1].fn, 'fn1499');
 
     // eslint-disable-next-line no-console
     console.log('trace batch size chunking OK');