@reproapp/node-sdk 0.0.44 → 0.0.45

package/dist/index.js

@@ -4875,11 +4875,11 @@ function reproMiddleware(cfg) {
                         ?? await materializeInlinePrivacyValueAsync('response.body', sanitizeRequestSnapshot(capturedBody), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
                 const responseBody = responseBodyMaterialization.value;
                 const requestValueEntries = [];
-                const bodyValueCapture = requestBodyMaterialization.skipped
+                const bodyValueCapture = requestBodyRaw === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
                         target: 'request.body',
-                        rawValue: req.body,
+                        rawValue: requestBodyRaw,
                         previewValue: requestBody,
                         capture: {
                             runtimeConfig: captureCfg,
@@ -4929,7 +4929,7 @@ function reproMiddleware(cfg) {
                         privacy: activePrivacy,
                     },
                 }, requestValueEntries);
-                const respBodyValueCapture = responseBodyMaterialization.skipped
+                const respBodyValueCapture = capturedBody === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
                         target: 'response.body',

package/package.json

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

package/src/index.ts

@@ -6036,11 +6036,11 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         );
                 const responseBody = responseBodyMaterialization.value;
                 const requestValueEntries: TraceValueBatchEntry[] = [];
-                const bodyValueCapture = requestBodyMaterialization.skipped
+                const bodyValueCapture = requestBodyRaw === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
                         target: 'request.body',
-                        rawValue: (req as any).body,
+                        rawValue: requestBodyRaw,
                         previewValue: requestBody,
                         capture: {
                             runtimeConfig: captureCfg,
@@ -6090,7 +6090,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         privacy: activePrivacy,
                     },
                 }, requestValueEntries);
-                const respBodyValueCapture = responseBodyMaterialization.skipped
+                const respBodyValueCapture = capturedBody === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
                         target: 'response.body',

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

@@ -142,6 +142,8 @@ async function main() {
         }
 
         const large = makeReqRes('S_perf_large_payload', 'A_perf_large_payload', '/large-payload');
+        large.req.method = 'POST';
+        large.req.body = largePayload();
         await invokeMiddleware(middleware, large.req, large.res, async () => {
             const traced = global.__repro_call(
                 largeTraceReturn,
@@ -160,12 +162,48 @@ async function main() {
 
         const backendRequest = eventsOf(capturedBodies, 'backend_request')[0]?.payload?.request;
         assert(backendRequest, JSON.stringify(capturedBodies));
+        assert.equal(backendRequest.body, undefined, JSON.stringify(backendRequest));
+        assert.equal(
+            backendRequest.bodyMaterialization?.reason,
+            'inline-size-limit',
+            JSON.stringify(backendRequest),
+        );
+        assert.equal(
+            backendRequest.bodyValueCapture?.status,
+            'stored',
+            JSON.stringify(backendRequest),
+        );
         assert.equal(backendRequest.respBody, undefined, JSON.stringify(backendRequest));
         assert.equal(
             backendRequest.respBodyMaterialization?.reason,
             'inline-size-limit',
             JSON.stringify(backendRequest),
         );
+        assert.equal(
+            backendRequest.respBodyValueCapture?.status,
+            'stored',
+            JSON.stringify(backendRequest),
+        );
+
+        const requestValues = eventsOf(capturedBodies, 'backend_request')
+            .flatMap((event) => Array.isArray(event?.payload?.requestValues) ? event.payload.requestValues : []);
+        const capturedRequestBody = requestValues.find((entry) =>
+            entry?.id === backendRequest.bodyValueCapture.valueId &&
+            entry?.target === 'request.body'
+        );
+        const capturedResponseBody = requestValues.find((entry) =>
+            entry?.id === backendRequest.respBodyValueCapture.valueId &&
+            entry?.target === 'response.body'
+        );
+        assert(capturedRequestBody, JSON.stringify(requestValues));
+        assert(capturedResponseBody, JSON.stringify(requestValues));
+        assert.equal(capturedRequestBody.value?.rows?.length, 400, JSON.stringify(capturedRequestBody));
+        assert.equal(capturedResponseBody.value?.rows?.length, 400, JSON.stringify(capturedResponseBody));
+        assert.equal(
+            capturedResponseBody.value.rows[399].depot,
+            'depot-399',
+            JSON.stringify(capturedResponseBody),
+        );
 
         const traceEvents = eventsOf(capturedBodies, 'trace_batch')
             .flatMap((event) => Array.isArray(event?.payload?.trace) ? event.payload.trace : []);

package/test/kafka-runtime-privacy-policy.test.js

@@ -307,7 +307,7 @@ async function testKafkaTraceFlushIsNotBlockedForeverByActiveHttpRequest() {
     }
 }
 
-async function testLargeHttpResponseBodyKeepsRequestMetadataWithoutInlineBody() {
+async function testLargeHttpResponseBodyKeepsFullValueOutOfBand() {
     const marker = 'OVERSIZED_HTTP_RESPONSE_MARKER';
     const capturedBodies = [];
     const originalFetch = global.fetch;
@@ -344,13 +344,28 @@ async function testLargeHttpResponseBodyKeepsRequestMetadataWithoutInlineBody()
             return text.includes('"event_type":"backend_request"') &&
                 text.includes('"reason":"inline-size-limit"');
         }));
-        const text = JSON.stringify(capturedBodies);
-        assert(!text.includes(marker), text);
-        assert(text.includes('respBodyMaterialization'), text);
-        assert(text.includes('"target":"response.body"'), text);
-        assert(!text.includes('__type":"json-string'), text);
-        assert(!text.includes('__truncatedKeys'), text);
-        assert(!text.includes('more chars'), text);
+        const backendEvent = capturedBodies
+            .flatMap((body) => Array.isArray(body?.events) ? body.events : [])
+            .find((event) => event?.event_type === 'backend_request');
+        const request = backendEvent?.payload?.request;
+        const requestValues = backendEvent?.payload?.requestValues;
+        assert(request, JSON.stringify(capturedBodies));
+        assert.strictEqual(request.respBody, undefined, JSON.stringify(request));
+        assert.strictEqual(request.respBodyMaterialization?.reason, 'inline-size-limit');
+        assert.strictEqual(request.respBodyValueCapture?.status, 'stored');
+        assert(!JSON.stringify(request).includes(marker), JSON.stringify(request));
+        const capturedResponse = requestValues?.find((entry) =>
+            entry?.id === request.respBodyValueCapture.valueId &&
+            entry?.target === 'response.body'
+        );
+        assert(capturedResponse, JSON.stringify(requestValues));
+        assert.strictEqual(
+            capturedResponse.value?.payload,
+            `${marker}:${'x'.repeat(12 * 1024)}`,
+        );
+        assert(!JSON.stringify(request).includes('__type":"json-string'), JSON.stringify(request));
+        assert(!JSON.stringify(request).includes('__truncatedKeys'), JSON.stringify(request));
+        assert(!JSON.stringify(request).includes('more chars'), JSON.stringify(request));
     } finally {
         await flushIngestQueue();
         global.fetch = originalFetch;
@@ -746,7 +761,7 @@ async function main() {
     await testKafkaConsumerTraceUsesConsumeTraceId();
     await testKafkaProducerCapturesFullPublishedMessageValue();
     await testKafkaTraceFlushIsNotBlockedForeverByActiveHttpRequest();
-    await testLargeHttpResponseBodyKeepsRequestMetadataWithoutInlineBody();
+    await testLargeHttpResponseBodyKeepsFullValueOutOfBand();
     await testJsonBuiltinTracePayloadsAreOmitted();
     await testLargeStringTraceValuesStayIngestibleAndCaptureFullValueOutOfBand();
     await testLargeStructuredTraceValuesStayIngestibleAndCaptureFullValueOutOfBand();