@reproapp/node-sdk 0.0.33 → 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)
@@ -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) {
@@ -3899,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 = [];
@@ -3928,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;
@@ -5175,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,
@@ -5302,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.33",
+  "version": "0.0.34",
   "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) {
@@ -4627,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[] = [];
@@ -4671,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:
@@ -6132,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,
@@ -6258,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

@@ -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);
     });
 }
 

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