@reproapp/node-sdk 0.0.33 → 0.0.35

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)
@@ -887,6 +900,8 @@ function isNativeMongoSuppressed(collection, op) {
         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) {
@@ -2988,9 +3003,12 @@ function limitRawInlinePrivacyValue(target, value) {
     return limited.skipped ? limited : null;
 }
 function materializeInlinePrivacyValue(target, value, cfg, req, trace, masking, privacy, db) {
-    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+    if (value === undefined) {
         return { value };
     }
+    if (shouldCapturePrivacyRaw(cfg)) {
+        return { value: limitMaterializedTraceInlineValue(value) };
+    }
     try {
         const valueAfterPrivacy = applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy, db);
         return { value: valueAfterPrivacy };
@@ -3007,9 +3025,12 @@ function materializeInlinePrivacyValue(target, value, cfg, req, trace, masking,
     }
 }
 async function materializeInlinePrivacyValueAsync(target, value, cfg, req, trace, masking, privacy, db) {
-    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+    if (value === undefined) {
         return { value };
     }
+    if (shouldCapturePrivacyRaw(cfg)) {
+        return { value: limitMaterializedTraceInlineValue(value) };
+    }
     try {
         const valueAfterPrivacy = await applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking, privacy, db);
         return { value: valueAfterPrivacy };
@@ -3899,7 +3920,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 = [];
@@ -3928,6 +3949,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;
@@ -5188,7 +5216,7 @@ function emitDbQuery(cfg, sid, aid, payload) {
         await als.run(runCtx, async () => {
             await emitDbQueryAsync(cfg, sid, aid, payload).catch(() => undefined);
         });
-    });
+    }, { priority: 'high' });
 }
 async function emitDbQueryAsync(cfg, sid, aid, payload) {
     if (!sid)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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;
@@ -1284,6 +1298,7 @@ function isNativeMongoSuppressed(collection: any, op: string): boolean {
     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) {
@@ -3595,9 +3610,12 @@ function materializeInlinePrivacyValue(
     privacy: NormalizedRuntimePrivacyPolicy | null,
     db?: RuntimePrivacyDbContext | null,
 ): InlinePrivacyMaterializationResult {
-    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+    if (value === undefined) {
         return { value };
     }
+    if (shouldCapturePrivacyRaw(cfg)) {
+        return { value: limitMaterializedTraceInlineValue(value) };
+    }
 
     try {
         const valueAfterPrivacy = applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy, db);
@@ -3624,9 +3642,12 @@ async function materializeInlinePrivacyValueAsync(
     privacy: NormalizedRuntimePrivacyPolicy | null,
     db?: RuntimePrivacyDbContext | null,
 ): Promise<InlinePrivacyMaterializationResult> {
-    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+    if (value === undefined) {
         return { value };
     }
+    if (shouldCapturePrivacyRaw(cfg)) {
+        return { value: limitMaterializedTraceInlineValue(value) };
+    }
 
     try {
         const valueAfterPrivacy = await applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking, privacy, db);
@@ -4627,7 +4648,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[] = [];
@@ -4671,6 +4692,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:
@@ -6145,7 +6173,7 @@ function emitDbQuery(cfg: any, sid?: string, aid?: string, payload?: any) {
         await als.run(runCtx, async () => {
             await emitDbQueryAsync(cfg, sid, aid, payload).catch(() => undefined);
         });
-    });
+    }, { priority: 'high' });
 }
 
 async function emitDbQueryAsync(cfg: any, sid?: string, aid?: string, payload?: any) {

package/test/mongodb-integration.test.js

@@ -139,6 +139,13 @@ function dbChanges(events) {
         .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();
@@ -185,9 +192,11 @@ async function testMongooseSuppressionDoesNotHideExplicitNativeInsertOne() {
         });
 
         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');
@@ -198,6 +207,7 @@ async function testMongooseSuppressionDoesNotHideExplicitNativeInsertOne() {
         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);
     });
 }
 
@@ -379,6 +389,68 @@ async function testNativeInsertOneIsCaptured() {
     });
 }
 
+async function testCaptureRawNativeInsertOneUsesJsonSafeTransportValues() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const sessionId = 'S_mongo_insert_raw_complex';
+        const actionId = 'A_mongo_insert_raw_complex';
+        const cfg = {
+            ...makeConfig(sessionId, actionId),
+            privacy: { environment: 'dev', captureRaw: true },
+        };
+
+        class FakeCollection {
+            constructor() {
+                this.collectionName = 'subjects';
+                this.dbName = 'clinical';
+            }
+
+            async insertOne(doc, options) {
+                assert.strictEqual(options.session.id, 'native-raw-complex-session-1');
+                doc._id = doc._id ?? 'subject-raw-complex-1';
+                return { acknowledged: true, insertedId: doc._id };
+            }
+        }
+
+        __reproTestHooks.patchMongoCollectionPrototypeForTest(FakeCollection.prototype, cfg);
+        const collection = new FakeCollection();
+        const doc = {
+            subjectNumber: '10013039',
+            status: 'screened',
+            counter: BigInt(42),
+        };
+        doc.self = doc;
+
+        await runCapturedRequest(cfg, sessionId, actionId, async () => {
+            await collection.insertOne(doc, {
+                session: {
+                    id: 'native-raw-complex-session-1',
+                    hasEnded: false,
+                    inTransaction: () => true,
+                },
+            });
+        });
+
+        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.query.driver, 'mongodb');
+        assert.strictEqual(change.query.doc.subjectNumber, '10013039');
+        assert.strictEqual(change.query.doc.counter, '42');
+        assert.deepStrictEqual(change.query.doc.self, { __reproCircularRef: '$.doc' });
+        assert.strictEqual(change.after.subjectNumber, '10013039');
+        assert.strictEqual(change.after.counter, '42');
+        assert.deepStrictEqual(change.after.self, { __reproCircularRef: '$' });
+        assert.strictEqual(manifest.expected.dbChange, 1);
+    });
+}
+
 async function testNativeUpdateOneUpsertIsCaptured() {
     await withCapturedFetch(async (capturedBodies) => {
         __reproTestHooks.resetSdkBackgroundQueuesForTest();
@@ -525,6 +597,7 @@ async function testNativeOperationFailureIsCapturedAndRethrown() {
     await testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne();
     await testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport();
     await testNativeInsertOneIsCaptured();
+    await testCaptureRawNativeInsertOneUsesJsonSafeTransportValues();
     await testNativeUpdateOneUpsertIsCaptured();
     await testNativeFindCursorToArrayIsCaptured();
     await testNativeOperationFailureIsCapturedAndRethrown();

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

@@ -34,6 +34,13 @@ function dbChanges(events) {
         .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';
@@ -131,16 +138,29 @@ async function main() {
             await Subject.create({ subjectNumber: '10013038', status: 'screened' });
         });
 
-        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length === 1);
+        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length >= 2);
+        await waitFor(() => requestCaptureManifests(flattenEvents(capturedBodies)).length === 1);
         await __reproTestHooks.drainSdkBackgroundQueueForTest();
         await flushIngestQueue();
 
         const changes = dbChanges(flattenEvents(capturedBodies));
-        assert.strictEqual(changes.length, 1);
-        assert.strictEqual(changes[0].type, 'mongo');
-        assert.strictEqual(changes[0].collection, 'subjects');
-        assert.strictEqual(changes[0].op, 'insert');
-        assert.strictEqual(changes[0].after.subjectNumber, '10013038');
+        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 {

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');