@reproapp/node-sdk 0.0.35 → 0.0.37

package/dist/index.js

@@ -330,7 +330,7 @@ let disabledFunctionTraceRules = computeDisabledFunctionTraceRules();
 let disabledFunctionTypePatterns = [];
 let disabledTraceFilePatterns = [];
 let __TRACE_LOG_PREF = null;
-let __FULL_VALUE_CAPTURE_ENABLED = false;
+let __FULL_VALUE_CAPTURE_ENABLED = true;
 function setInterceptorTracingEnabled(enabled) {
     const next = !!enabled;
     if (interceptorTracingEnabled === next)
@@ -581,9 +581,9 @@ function defaultTracerInitOpts() {
 /** Call this from the client app to enable tracing. Safe to call multiple times. */
 function initReproTracing(opts) {
     const options = opts ?? {};
-    if (hasOwn(options, 'fullValueCapture')) {
-        __FULL_VALUE_CAPTURE_ENABLED = options.fullValueCapture === true;
-    }
+    __FULL_VALUE_CAPTURE_ENABLED = hasOwn(options, 'fullValueCapture')
+        ? options.fullValueCapture === true
+        : true;
     if (hasOwn(options, 'traceInterceptors')) {
         setInterceptorTracingEnabled(!!options.traceInterceptors);
     }

package/package.json

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

package/src/index.ts

@@ -604,7 +604,7 @@ let disabledFunctionTraceRules: DisableFunctionTraceConfig[] = computeDisabledFu
 let disabledFunctionTypePatterns: Array<string | number | RegExp> = [];
 let disabledTraceFilePatterns: Array<string | number | RegExp> = [];
 let __TRACE_LOG_PREF: boolean | null = null;
-let __FULL_VALUE_CAPTURE_ENABLED = false;
+let __FULL_VALUE_CAPTURE_ENABLED = true;
 
 function setInterceptorTracingEnabled(enabled: boolean) {
     const next = !!enabled;
@@ -929,9 +929,9 @@ function defaultTracerInitOpts(): TracerInitOpts {
 export function initReproTracing(opts?: ReproTracingInitOptions) {
     const options = opts ?? {};
 
-    if (hasOwn(options, 'fullValueCapture')) {
-        __FULL_VALUE_CAPTURE_ENABLED = options.fullValueCapture === true;
-    }
+    __FULL_VALUE_CAPTURE_ENABLED = hasOwn(options, 'fullValueCapture')
+        ? options.fullValueCapture === true
+        : true;
 
     if (hasOwn(options, 'traceInterceptors')) {
         setInterceptorTracingEnabled(!!options.traceInterceptors);

package/test/client-performance-regression.test.js

@@ -170,10 +170,28 @@ async function main() {
             event?.returnValue,
         );
         assert(largeReturnExit, JSON.stringify(traceEvents));
-        assert.deepEqual(
-            largeReturnExit.returnValue,
-            { __kind: 'omitted', reason: 'inline-size-limit' },
+        assert(
+            Buffer.byteLength(JSON.stringify(largeReturnExit.returnValue), 'utf8') <= 2048,
+            JSON.stringify(largeReturnExit.returnValue),
         );
+        assert.equal(
+            largeReturnExit.returnValueCapture?.status,
+            'stored',
+            JSON.stringify(largeReturnExit),
+        );
+        assert(
+            typeof largeReturnExit.returnValueCapture?.valueId === 'string' &&
+                largeReturnExit.returnValueCapture.valueId.length > 0,
+            JSON.stringify(largeReturnExit),
+        );
+        const traceValues = eventsOf(capturedBodies, 'trace_batch')
+            .flatMap((event) => Array.isArray(event?.payload?.traceValues) ? event.payload.traceValues : []);
+        const capturedReturnValue = traceValues.find((entry) =>
+            entry?.id === largeReturnExit.returnValueCapture.valueId &&
+            entry?.target === 'trace.returnValue'
+        );
+        assert(capturedReturnValue, JSON.stringify(traceValues));
+        assert.equal(capturedReturnValue.value?.rows?.length, 400, JSON.stringify(capturedReturnValue));
 
         console.log('client performance regression guards OK');
     } finally {

package/test/mongodb-integration.test.js

@@ -332,6 +332,151 @@ async function testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport(
     });
 }
 
+async function testClientScreenNativeMongoInsertOneShapeIsCaptured() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const sessionId = 'S_client_screen_native_insert';
+        const actionId = 'A_client_screen_native_insert';
+        const cfg = {
+            ...makeConfig(sessionId, actionId),
+            privacy: { environment: 'dev', captureRaw: true },
+        };
+
+        class FakeCollection {
+            constructor(dbName, collectionName) {
+                this.dbName = dbName;
+                this.collectionName = collectionName;
+            }
+
+            async insertOne(doc, options) {
+                assert.strictEqual(options.session.id, 'screen-transaction-session-1');
+                doc._id = doc._id ?? 'subject-screen-1';
+                return { acknowledged: true, insertedId: doc._id };
+            }
+        }
+
+        class FakeDb {
+            constructor(dbName) {
+                this.databaseName = dbName;
+            }
+
+            collection(collectionName) {
+                return new FakeCollection(this.databaseName, collectionName);
+            }
+        }
+
+        class FakeMongoClient {
+            db(dbName) {
+                return new FakeDb(dbName);
+            }
+        }
+
+        __reproTestHooks.patchMongoDbModuleForTest({
+            MongoClient: FakeMongoClient,
+            Db: FakeDb,
+        }, cfg);
+
+        const dbClient = new FakeMongoClient();
+        const connectionDictionary = {
+            pulmovant: {
+                db: {
+                    databaseName: 'dev-configure-pulmovant',
+                },
+            },
+        };
+        const collectionNames = {
+            SUBJECTS: 'subjects',
+        };
+        const completeVisitTypeLimitChecks = async () => null;
+
+        async function screen(req, newSubjectRecord, openUserTransaction) {
+            newSubjectRecord.lastUserTransactionId = openUserTransaction._id;
+
+            const dbName = connectionDictionary[req.query.tenantId].db.databaseName;
+            const subjectsCollection = await dbClient.db(dbName).collection(collectionNames.SUBJECTS);
+
+            const checkResult = await completeVisitTypeLimitChecks();
+            if (checkResult) return { success: false, message: checkResult };
+
+            const subjectSaveResult = await subjectsCollection.insertOne(newSubjectRecord, {
+                session: req.mongoSession,
+            });
+
+            if (!subjectSaveResult.acknowledged) {
+                throw new Error('Error creating subject');
+            }
+
+            return { success: true, insertedId: subjectSaveResult.insertedId };
+        }
+
+        const newSubjectRecord = {
+            activityLog: {
+                createdBy: '678a70921acd637a6de91c1f',
+                createdByUserName: "Pat O'Brien",
+                createdOn: '2026-06-22 10:14:13.151000000',
+            },
+            demographics: [
+                { key: 'age', type: 'Number', value: '35' },
+                { key: 'dateOfBirth', type: 'String', value: '1990' },
+                { key: 'gender', type: 'String', value: 'Female' },
+            ],
+            protocolId: '69e77c77ab541cfac917b36b',
+            site: {
+                id: '69f0c10256a07ef2204a6ef6',
+                number: '1001',
+            },
+            status: 'Active',
+            subjectFlags: {
+                isRescreen: false,
+            },
+            subjectNumber: '10013060',
+            subjectStatus: 'Screened',
+            subjectStatusOption: 'Screened',
+        };
+
+        await runCapturedRequest(cfg, sessionId, actionId, async () => {
+            const result = await screen(
+                {
+                    query: { tenantId: 'pulmovant' },
+                    mongoSession: {
+                        id: 'screen-transaction-session-1',
+                        hasEnded: false,
+                        inTransaction: () => true,
+                    },
+                },
+                newSubjectRecord,
+                { _id: '6a390af395744083f43fd484' },
+            );
+            assert.deepStrictEqual(result, {
+                success: true,
+                insertedId: 'subject-screen-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-screen-1');
+        assert.strictEqual(change.query.driver, 'mongodb');
+        assert.strictEqual(change.query.db, 'dev-configure-pulmovant');
+        assert.strictEqual(change.query.doc.subjectNumber, '10013060');
+        assert.strictEqual(change.query.doc.lastUserTransactionId, '6a390af395744083f43fd484');
+        assert.strictEqual(change.query.options.session.__kind, 'mongodb_client_session');
+        assert.strictEqual(change.query.options.session.id, 'screen-transaction-session-1');
+        assert.strictEqual(change.query.options.session.inTransaction, true);
+        assert.strictEqual(change.after.subjectNumber, '10013060');
+        assert.strictEqual(change.resultMeta.insertedId, 'subject-screen-1');
+        assert.strictEqual(change.resultMeta.acknowledged, true);
+        assert.strictEqual(manifest.expected.dbChange, 1);
+    });
+}
+
 async function testNativeInsertOneIsCaptured() {
     await withCapturedFetch(async (capturedBodies) => {
         __reproTestHooks.resetSdkBackgroundQueuesForTest();
@@ -596,6 +741,7 @@ async function testNativeOperationFailureIsCapturedAndRethrown() {
     await testMongooseSuppressionDoesNotHideExplicitNativeInsertOne();
     await testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne();
     await testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport();
+    await testClientScreenNativeMongoInsertOneShapeIsCaptured();
     await testNativeInsertOneIsCaptured();
     await testCaptureRawNativeInsertOneUsesJsonSafeTransportValues();
     await testNativeUpdateOneUpsertIsCaptured();