@reproapp/node-sdk 0.0.36 → 0.0.38

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);
     }
@@ -4092,6 +4092,45 @@ async function maybeCaptureDbValueAsync(params, sink) {
     }
     return result.captureRef;
 }
+function pushUniqueCaptureCandidate(candidates, value) {
+    if (value === undefined)
+        return;
+    if (candidates.some((candidate) => candidate === value))
+        return;
+    candidates.push(value);
+}
+function buildResultMetaFullValueCandidates(resultMetaRaw, resultMetaSource) {
+    const candidates = [];
+    pushUniqueCaptureCandidate(candidates, resultMetaRaw);
+    if (resultMetaSource &&
+        typeof resultMetaSource === 'object' &&
+        Object.prototype.hasOwnProperty.call(resultMetaSource, 'result')) {
+        pushUniqueCaptureCandidate(candidates, resultMetaSource.result);
+    }
+    pushUniqueCaptureCandidate(candidates, resultMetaSource);
+    return candidates;
+}
+async function maybeCaptureDbValueFromCandidatesAsync(params, sink) {
+    let skippedRef;
+    for (const rawValue of params.rawValues) {
+        const result = await createCapturedValueEntryAsync({
+            target: params.target,
+            rawValue,
+            previewValue: params.previewValue,
+            capture: params.capture,
+        });
+        if (!result)
+            continue;
+        if (result.entry) {
+            sink.push(result.entry);
+            return result.captureRef;
+        }
+        if (!skippedRef) {
+            skippedRef = result.captureRef;
+        }
+    }
+    return skippedRef;
+}
 function reproMiddleware(cfg) {
     const masking = normalizeMaskingConfig(cfg.masking);
     patchMongoDb(cfg);
@@ -5285,9 +5324,9 @@ async function emitDbQueryAsync(cfg, sid, aid, payload) {
         previewValue: queryPreview,
         capture,
     }, dbValues);
-    const resultMetaValueCapture = resultMetaMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
+    const resultMetaValueCapture = resultMetaMaterialization.skipped ? undefined : await maybeCaptureDbValueFromCandidatesAsync({
         target: 'db.resultMeta',
-        rawValue: payload.resultMetaRaw ?? resultMetaSource,
+        rawValues: buildResultMetaFullValueCandidates(payload.resultMetaRaw, resultMetaSource),
         previewValue: resultMetaPreview,
         capture,
     }, dbValues);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "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);
@@ -4955,6 +4955,55 @@ async function maybeCaptureDbValueAsync(
     return result.captureRef;
 }
 
+function pushUniqueCaptureCandidate(candidates: any[], value: any): void {
+    if (value === undefined) return;
+    if (candidates.some((candidate) => candidate === value)) return;
+    candidates.push(value);
+}
+
+function buildResultMetaFullValueCandidates(resultMetaRaw: any, resultMetaSource: any): any[] {
+    const candidates: any[] = [];
+    pushUniqueCaptureCandidate(candidates, resultMetaRaw);
+    if (
+        resultMetaSource &&
+        typeof resultMetaSource === 'object' &&
+        Object.prototype.hasOwnProperty.call(resultMetaSource, 'result')
+    ) {
+        pushUniqueCaptureCandidate(candidates, resultMetaSource.result);
+    }
+    pushUniqueCaptureCandidate(candidates, resultMetaSource);
+    return candidates;
+}
+
+async function maybeCaptureDbValueFromCandidatesAsync(
+    params: {
+        target: 'db.pk' | 'db.before' | 'db.after' | 'db.query' | 'db.resultMeta' | 'db.error';
+        rawValues: any[];
+        previewValue: any;
+        capture: FullValueCaptureContext;
+    },
+    sink: TraceValueBatchEntry[],
+): Promise<TraceValueCaptureRef | undefined> {
+    let skippedRef: TraceValueCaptureRef | undefined;
+    for (const rawValue of params.rawValues) {
+        const result = await createCapturedValueEntryAsync({
+            target: params.target,
+            rawValue,
+            previewValue: params.previewValue,
+            capture: params.capture,
+        });
+        if (!result) continue;
+        if (result.entry) {
+            sink.push(result.entry);
+            return result.captureRef;
+        }
+        if (!skippedRef) {
+            skippedRef = result.captureRef;
+        }
+    }
+    return skippedRef;
+}
+
 // ===================================================================
 // reproMiddleware — unchanged behavior + passive per-request trace
 // ===================================================================
@@ -6241,9 +6290,9 @@ async function emitDbQueryAsync(cfg: any, sid?: string, aid?: string, payload?:
         previewValue: queryPreview,
         capture,
     }, dbValues);
-    const resultMetaValueCapture = resultMetaMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
+    const resultMetaValueCapture = resultMetaMaterialization.skipped ? undefined : await maybeCaptureDbValueFromCandidatesAsync({
         target: 'db.resultMeta',
-        rawValue: payload.resultMetaRaw ?? resultMetaSource,
+        rawValues: buildResultMetaFullValueCandidates(payload.resultMetaRaw, resultMetaSource),
         previewValue: resultMetaPreview,
         capture,
     }, dbValues);

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

@@ -133,12 +133,24 @@ function execPre(hooks, name, context) {
     });
 }
 
+function execPost(hooks, name, context, args = []) {
+    return new Promise((resolve, reject) => {
+        hooks.execPost(name, context, args, {}, (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 dbValueEntries(events) {
+    return events
+        .filter((event) => event.event_type === 'db_change')
+        .flatMap((event) => Array.isArray(event.payload?.dbValues) ? event.payload.dbValues : []);
+}
+
 function requestCaptureManifests(events) {
     return events
         .filter((event) => event.event_type === 'request_capture_manifest')
@@ -146,6 +158,81 @@ function requestCaptureManifests(events) {
         .filter(Boolean);
 }
 
+function makeNotificationModuleDocument() {
+    const notificationPreferences = Array.from({ length: 24 }, (_, index) => ({
+        trigger: 'SubjectScreened',
+        enabled: true,
+        channels: [
+            {
+                type: 'email',
+                template: {
+                    subject: `Participant Screening ${index}`,
+                    html: `<p>Screening notification ${index}</p>`,
+                },
+                recipients: {
+                    to: ['noreply@korioclinical.com'],
+                    cc: [
+                        `pobrien+dev-conf-csm${index}@korioclinical.com`,
+                        `mnebot+site-monitor${index}@korioclinical.com`,
+                    ],
+                    bcc: [`audit-${index}@korioclinical.com`],
+                },
+            },
+        ],
+    }));
+    const notificationTrigger = Array.from({ length: 24 }, (_, index) => ({
+        active: true,
+        event: 'SubjectScreened',
+        visitType: 'Screening',
+        subjectType: 'Participant',
+        rules: [
+            {
+                condition: {
+                    path: 'subject.subjectStatusOption',
+                    operator: 'equals',
+                    value: 'Screened',
+                },
+                action: {
+                    module: 'NotificationGeneratorService',
+                    method: 'SubjectScreened',
+                    order: index,
+                },
+            },
+        ],
+    }));
+
+    return {
+        __t: 'NotificationModule',
+        _id: '69e77c77ab541cfac917b37a',
+        active: true,
+        environment: 'dev-configure-pulmovant',
+        notificationPreferences,
+        notification_trigger: notificationTrigger,
+        protocol: {
+            id: '69e77c77ab541cfac917b36b',
+            name: 'RVT-2301-301',
+        },
+        schema_version: 1,
+        sponsor_name: 'Pulmovant',
+        study_name: 'RVT-2301-301',
+    };
+}
+
+class NotificationModuleHostDocument {
+    constructor(value) {
+        this.$__ = {};
+        this.value = value;
+    }
+
+    toObject() {
+        return JSON.parse(JSON.stringify(this.value));
+    }
+
+    toJSON() {
+        return this.toObject();
+    }
+}
+
 async function testMongooseSuppressionDoesNotHideExplicitNativeInsertOne() {
     await withCapturedFetch(async (capturedBodies) => {
         __reproTestHooks.resetSdkBackgroundQueuesForTest();
@@ -477,6 +564,82 @@ async function testClientScreenNativeMongoInsertOneShapeIsCaptured() {
     });
 }
 
+async function testLargeMongooseFindOneResultStoresFullResultMetaSidecar() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const sessionId = 'S_mongoose_large_result_meta';
+        const actionId = 'A_mongoose_large_result_meta';
+        const cfg = {
+            ...makeConfig(sessionId, actionId),
+            privacy: { environment: 'dev', captureRaw: true },
+        };
+
+        const schema = new mongoose.Schema({}, { strict: false });
+        reproMongoosePlugin(cfg)(schema);
+
+        const notificationModule = makeNotificationModuleDocument();
+        const rawResult = new NotificationModuleHostDocument(notificationModule);
+        const queryContext = {
+            model: {
+                collection: {
+                    name: 'configStudy',
+                },
+            },
+            getFilter: () => ({
+                __t: 'NotificationModule',
+                active: true,
+                protocol: {
+                    id: '69e77c77ab541cfac917b36b',
+                },
+            }),
+            getUpdate: () => undefined,
+            projection: () => undefined,
+            getOptions: () => ({ lean: false }),
+        };
+
+        await runCapturedRequest(cfg, sessionId, actionId, async () => {
+            await execPre(schema.s.hooks, 'findOne', queryContext);
+            await execPost(schema.s.hooks, 'findOne', queryContext, [rawResult]);
+        });
+
+        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length === 1);
+        await waitFor(() => dbValueEntries(flattenEvents(capturedBodies)).some((entry) => entry.target === 'db.resultMeta'));
+        await drainSdk();
+
+        const [change] = dbChanges(flattenEvents(capturedBodies));
+        const values = dbValueEntries(flattenEvents(capturedBodies));
+        const resultMetaValue = values.find((entry) => entry.id === change.resultMetaValueCapture?.valueId);
+
+        assert.strictEqual(change.type, 'mongo');
+        assert.strictEqual(change.collection, 'configStudy');
+        assert.strictEqual(change.op, 'findOne');
+        assert.strictEqual(change.query.filter.__t, 'NotificationModule');
+        assert.strictEqual(change.resultMeta.docsCount, 1);
+        assert.deepStrictEqual(change.resultMeta.result.notificationPreferences[0], {
+            __kind: 'omitted',
+            reason: 'depth>3',
+        });
+        assert.deepStrictEqual(change.resultMeta.result.notification_trigger[0], {
+            __kind: 'omitted',
+            reason: 'depth>3',
+        });
+        assert.strictEqual(change.resultMetaValueCapture.status, 'stored');
+        assert.ok(change.resultMetaValueCapture.valueId, 'expected resultMeta value id');
+        assert.ok(resultMetaValue, 'expected matching db.resultMeta sidecar');
+        assert.strictEqual(resultMetaValue.target, 'db.resultMeta');
+        assert.strictEqual(resultMetaValue.value.__t, 'NotificationModule');
+        assert.strictEqual(resultMetaValue.value.notificationPreferences.length, 24);
+        assert.strictEqual(
+            resultMetaValue.value.notificationPreferences[0].channels[0].recipients.cc[0],
+            'pobrien+dev-conf-csm0@korioclinical.com',
+        );
+        assert.strictEqual(
+            resultMetaValue.value.notification_trigger[0].rules[0].action.method,
+            'SubjectScreened',
+        );
+    });
+}
+
 async function testNativeInsertOneIsCaptured() {
     await withCapturedFetch(async (capturedBodies) => {
         __reproTestHooks.resetSdkBackgroundQueuesForTest();
@@ -742,6 +905,7 @@ async function testNativeOperationFailureIsCapturedAndRethrown() {
     await testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne();
     await testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport();
     await testClientScreenNativeMongoInsertOneShapeIsCaptured();
+    await testLargeMongooseFindOneResultStoresFullResultMetaSidecar();
     await testNativeInsertOneIsCaptured();
     await testCaptureRawNativeInsertOneUsesJsonSafeTransportValues();
     await testNativeUpdateOneUpsertIsCaptured();