@reproapp/node-sdk 0.0.21 → 0.0.23

package/dist/index.js

@@ -843,7 +843,7 @@ const SDK_BACKGROUND_IDLE_DELAY_MS = (() => {
     const env = Number(process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS);
     if (Number.isFinite(env) && env >= 0)
         return env;
-    return 25;
+    return 5000;
 })();
 const SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = (() => {
     const env = Number(process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS);
@@ -852,10 +852,17 @@ const SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = (() => {
     return 1000;
 })();
 const SDK_BACKGROUND_MAX_DEFER_MS = (() => {
-    const env = Number(process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS);
+    const raw = String(process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS ?? '').trim().toLowerCase();
+    if (!raw) {
+        return Number.POSITIVE_INFINITY;
+    }
+    if (raw === 'off' || raw === 'never' || raw === 'infinite' || raw === 'infinity' || raw === '-1') {
+        return Number.POSITIVE_INFINITY;
+    }
+    const env = Number(raw);
     if (Number.isFinite(env) && env >= 0)
         return Math.trunc(env);
-    return 2000;
+    return Number.POSITIVE_INFINITY;
 })();
 const SDK_BACKGROUND_WORK_TIMEOUT_MS = (() => {
     const env = Number(process.env.REPRO_SDK_BACKGROUND_WORK_TIMEOUT_MS);
@@ -915,7 +922,9 @@ function noteClientActivity(now = Date.now()) {
 }
 function getSdkBackgroundDelayMs(now = Date.now()) {
     if (hasActiveClientRequests()) {
-        if (oldestActiveClientRequestAt !== null && SDK_BACKGROUND_MAX_DEFER_MS >= 0) {
+        if (oldestActiveClientRequestAt !== null &&
+            Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS) &&
+            SDK_BACKGROUND_MAX_DEFER_MS >= 0) {
             const activeForMs = now - oldestActiveClientRequestAt;
             if (activeForMs >= SDK_BACKGROUND_MAX_DEFER_MS)
                 return 0;
@@ -1703,6 +1712,18 @@ const TRACE_BATCH_MAX_SERIALIZED_BYTES = (() => {
         return Math.trunc(env);
     return 512 * 1024;
 })();
+const TRACE_MAX_EVENTS_PER_REQUEST = (() => {
+    const env = Number(process.env.REPRO_TRACE_MAX_EVENTS_PER_REQUEST);
+    if (Number.isFinite(env) && env > 0)
+        return Math.trunc(env);
+    return 1000;
+})();
+const TRACE_MAX_BATCHES_PER_REQUEST = (() => {
+    const env = Number(process.env.REPRO_TRACE_MAX_BATCHES_PER_REQUEST);
+    if (Number.isFinite(env) && env > 0)
+        return Math.trunc(env);
+    return 8;
+})();
 const TRACE_FLUSH_DELAY_MS = 20;
 // Choose how to order trace events in payloads.
 //  - "chronological" (default): preserve event arrival order (no reshuffle).
@@ -2259,54 +2280,69 @@ async function materializePendingTraceEvents(events, params) {
             parentSpanId: evt.parentSpanId ?? null,
         };
         if (!omitJsonBuiltinValues && pending.argsRaw !== undefined) {
-            const argsMaterialized = await materializeTracePrivacyValueAsync('trace.args', sanitizeTraceArgsForPrivacy(pending.argsRaw), params.cfg, params.maskReq, candidate, params.masking, activePrivacy);
-            evt.args = limitMaterializedTraceInlineValue(argsMaterialized);
-            const argsValueCapture = await maybeCaptureTraceValueAsync({
-                target: 'trace.args',
-                rawValue: pending.argsRaw,
-                previewValue: evt.args,
-                capture: captureContext,
-                metadata: traceValueMetadata,
-            });
-            if (argsValueCapture?.entry) {
-                attachTraceValueEntry(evt, argsValueCapture.entry);
+            if (!__FULL_VALUE_CAPTURE_ENABLED && traceInlineValueExceedsLimit(pending.argsRaw)) {
+                evt.args = makeOmittedValue('inline-size-limit');
             }
-            if (argsValueCapture?.captureRef) {
-                evt.argsValueCapture = argsValueCapture.captureRef;
+            else {
+                const argsMaterialized = await materializeTracePrivacyValueAsync('trace.args', sanitizeTraceArgsForPrivacy(pending.argsRaw), params.cfg, params.maskReq, candidate, params.masking, activePrivacy);
+                evt.args = limitMaterializedTraceInlineValue(argsMaterialized);
+                const argsValueCapture = await maybeCaptureTraceValueAsync({
+                    target: 'trace.args',
+                    rawValue: pending.argsRaw,
+                    previewValue: evt.args,
+                    capture: captureContext,
+                    metadata: traceValueMetadata,
+                });
+                if (argsValueCapture?.entry) {
+                    attachTraceValueEntry(evt, argsValueCapture.entry);
+                }
+                if (argsValueCapture?.captureRef) {
+                    evt.argsValueCapture = argsValueCapture.captureRef;
+                }
             }
         }
         if (!omitJsonBuiltinValues && pending.returnValueRaw !== undefined) {
-            const returnValueMaterialized = await materializeTracePrivacyValueAsync('trace.returnValue', sanitizeTraceValueForPrivacy(pending.returnValueRaw), params.cfg, params.maskReq, candidate, params.masking, activePrivacy);
-            evt.returnValue = limitMaterializedTraceInlineValue(returnValueMaterialized);
-            const returnValueCapture = await maybeCaptureTraceValueAsync({
-                target: 'trace.returnValue',
-                rawValue: pending.returnValueRaw,
-                previewValue: evt.returnValue,
-                capture: captureContext,
-                metadata: traceValueMetadata,
-            });
-            if (returnValueCapture?.entry) {
-                attachTraceValueEntry(evt, returnValueCapture.entry);
+            if (!__FULL_VALUE_CAPTURE_ENABLED && traceInlineValueExceedsLimit(pending.returnValueRaw)) {
+                evt.returnValue = makeOmittedValue('inline-size-limit');
             }
-            if (returnValueCapture?.captureRef) {
-                evt.returnValueCapture = returnValueCapture.captureRef;
+            else {
+                const returnValueMaterialized = await materializeTracePrivacyValueAsync('trace.returnValue', sanitizeTraceValueForPrivacy(pending.returnValueRaw), params.cfg, params.maskReq, candidate, params.masking, activePrivacy);
+                evt.returnValue = limitMaterializedTraceInlineValue(returnValueMaterialized);
+                const returnValueCapture = await maybeCaptureTraceValueAsync({
+                    target: 'trace.returnValue',
+                    rawValue: pending.returnValueRaw,
+                    previewValue: evt.returnValue,
+                    capture: captureContext,
+                    metadata: traceValueMetadata,
+                });
+                if (returnValueCapture?.entry) {
+                    attachTraceValueEntry(evt, returnValueCapture.entry);
+                }
+                if (returnValueCapture?.captureRef) {
+                    evt.returnValueCapture = returnValueCapture.captureRef;
+                }
             }
         }
         if (pending.errorRaw !== undefined) {
-            const errorMaterialized = await materializeTracePrivacyValueAsync('trace.error', sanitizeTraceValueForPrivacy(pending.errorRaw), params.cfg, params.maskReq, candidate, params.masking, activePrivacy);
-            evt.error = limitMaterializedTraceInlineValue(errorMaterialized);
-            const errorValueCapture = await maybeCaptureTraceValueAsync({
-                target: 'trace.error',
-                rawValue: pending.errorRaw,
-                previewValue: evt.error,
-                capture: captureContext,
-                metadata: traceValueMetadata,
-            });
-            if (errorValueCapture?.entry) {
-                attachTraceValueEntry(evt, errorValueCapture.entry);
+            if (!__FULL_VALUE_CAPTURE_ENABLED && traceInlineValueExceedsLimit(pending.errorRaw)) {
+                evt.error = makeOmittedValue('inline-size-limit');
             }
-            if (errorValueCapture?.captureRef) {
-                evt.errorValueCapture = errorValueCapture.captureRef;
+            else {
+                const errorMaterialized = await materializeTracePrivacyValueAsync('trace.error', sanitizeTraceValueForPrivacy(pending.errorRaw), params.cfg, params.maskReq, candidate, params.masking, activePrivacy);
+                evt.error = limitMaterializedTraceInlineValue(errorMaterialized);
+                const errorValueCapture = await maybeCaptureTraceValueAsync({
+                    target: 'trace.error',
+                    rawValue: pending.errorRaw,
+                    previewValue: evt.error,
+                    capture: captureContext,
+                    metadata: traceValueMetadata,
+                });
+                if (errorValueCapture?.entry) {
+                    attachTraceValueEntry(evt, errorValueCapture.entry);
+                }
+                if (errorValueCapture?.captureRef) {
+                    evt.errorValueCapture = errorValueCapture.captureRef;
+                }
             }
         }
     }
@@ -2808,7 +2844,22 @@ function traceInlineValueExceedsLimit(value) {
     return boundedSerializedTraceValueLength(value, TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS).exceeded;
 }
 function limitInlinePrivacyValue(target, value) {
-    void target;
+    if (value === undefined) {
+        return { value };
+    }
+    const serialized = boundedSerializedTraceValueLength(value, TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS);
+    if (serialized.exceeded) {
+        return {
+            value: undefined,
+            skipped: {
+                status: 'skipped',
+                reason: 'inline-size-limit',
+                target,
+                serializedLength: Math.max(serialized.length, TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS + 1),
+                limit: TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS,
+            },
+        };
+    }
     return { value };
 }
 function limitRawInlinePrivacyValue(target, value) {
@@ -3727,22 +3778,31 @@ function estimateTraceBatchSerializedBytes(batch, requestRid, actionId, batchInd
 function chunkTraceEventsForTransport(events, requestRid, actionId) {
     if (!Array.isArray(events) || events.length === 0)
         return [];
-    const countBatches = chunkArray(events, TRACE_BATCH_SIZE);
+    const boundedEvents = events.slice(0, TRACE_MAX_EVENTS_PER_REQUEST);
+    const countBatches = chunkArray(boundedEvents, TRACE_BATCH_SIZE);
     const sizedBatches = [];
     let current = [];
     for (const event of countBatches.flat()) {
+        if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
+            break;
+        }
         const candidate = current.concat(event);
         const batchIndex = sizedBatches.length;
         const estimatedBytes = estimateTraceBatchSerializedBytes(candidate, requestRid, actionId, batchIndex);
         if (current.length > 0 &&
             estimatedBytes > TRACE_BATCH_MAX_SERIALIZED_BYTES) {
             sizedBatches.push(current);
+            if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
+                current = [];
+                break;
+            }
             current = [event];
             continue;
         }
         current = candidate;
     }
-    if (current.length > 0) {
+    if (current.length > 0 &&
+        sizedBatches.length < TRACE_MAX_BATCHES_PER_REQUEST) {
         sizedBatches.push(current);
     }
     return sizedBatches;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,7 @@
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build",
-    "test": "npm run build && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-capture-background.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node test/ingest-queue-retention.test.js && node test/ingest-timeout.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js",
+    "test": "npm run build && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-capture-background.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node test/ingest-queue-retention.test.js && node test/ingest-timeout.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js",
     "test:containers": "npm run build && node test/runtime-no-double-invoke.testcontainers.test.js && node test/wrap-plugin-super-call.testcontainers.test.js && node test/function-arg-identity.testcontainers.test.js"
   },
   "peerDependencies": {

package/src/index.ts

@@ -1239,7 +1239,7 @@ function nextRequestId(base: number | string): string {
 const SDK_BACKGROUND_IDLE_DELAY_MS = (() => {
     const env = Number(process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS);
     if (Number.isFinite(env) && env >= 0) return env;
-    return 25;
+    return 5000;
 })();
 
 const SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = (() => {
@@ -1249,9 +1249,16 @@ const SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = (() => {
 })();
 
 const SDK_BACKGROUND_MAX_DEFER_MS = (() => {
-    const env = Number(process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS);
+    const raw = String(process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS ?? '').trim().toLowerCase();
+    if (!raw) {
+        return Number.POSITIVE_INFINITY;
+    }
+    if (raw === 'off' || raw === 'never' || raw === 'infinite' || raw === 'infinity' || raw === '-1') {
+        return Number.POSITIVE_INFINITY;
+    }
+    const env = Number(raw);
     if (Number.isFinite(env) && env >= 0) return Math.trunc(env);
-    return 2000;
+    return Number.POSITIVE_INFINITY;
 })();
 
 const SDK_BACKGROUND_WORK_TIMEOUT_MS = (() => {
@@ -1319,7 +1326,11 @@ function noteClientActivity(now = Date.now()): void {
 
 function getSdkBackgroundDelayMs(now = Date.now()): number {
     if (hasActiveClientRequests()) {
-        if (oldestActiveClientRequestAt !== null && SDK_BACKGROUND_MAX_DEFER_MS >= 0) {
+        if (
+            oldestActiveClientRequestAt !== null &&
+            Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS) &&
+            SDK_BACKGROUND_MAX_DEFER_MS >= 0
+        ) {
             const activeForMs = now - oldestActiveClientRequestAt;
             if (activeForMs >= SDK_BACKGROUND_MAX_DEFER_MS) return 0;
             return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, Math.max(0, SDK_BACKGROUND_MAX_DEFER_MS - activeForMs));
@@ -2105,6 +2116,16 @@ const TRACE_BATCH_MAX_SERIALIZED_BYTES = (() => {
     if (Number.isFinite(env) && env > 0) return Math.trunc(env);
     return 512 * 1024;
 })();
+const TRACE_MAX_EVENTS_PER_REQUEST = (() => {
+    const env = Number(process.env.REPRO_TRACE_MAX_EVENTS_PER_REQUEST);
+    if (Number.isFinite(env) && env > 0) return Math.trunc(env);
+    return 1000;
+})();
+const TRACE_MAX_BATCHES_PER_REQUEST = (() => {
+    const env = Number(process.env.REPRO_TRACE_MAX_BATCHES_PER_REQUEST);
+    if (Number.isFinite(env) && env > 0) return Math.trunc(env);
+    return 8;
+})();
 const TRACE_FLUSH_DELAY_MS = 20;
 // Choose how to order trace events in payloads.
 //  - "chronological" (default): preserve event arrival order (no reshuffle).
@@ -2704,78 +2725,90 @@ async function materializePendingTraceEvents(
         };
 
         if (!omitJsonBuiltinValues && pending.argsRaw !== undefined) {
-            const argsMaterialized = await materializeTracePrivacyValueAsync(
-                'trace.args',
-                sanitizeTraceArgsForPrivacy(pending.argsRaw),
-                params.cfg,
-                params.maskReq,
-                candidate,
-                params.masking,
-                activePrivacy,
-            );
-            evt.args = limitMaterializedTraceInlineValue(argsMaterialized);
-            const argsValueCapture = await maybeCaptureTraceValueAsync({
-                target: 'trace.args',
-                rawValue: pending.argsRaw,
-                previewValue: evt.args,
-                capture: captureContext,
-                metadata: traceValueMetadata,
-            });
-            if (argsValueCapture?.entry) {
-                attachTraceValueEntry(evt, argsValueCapture.entry);
-            }
-            if (argsValueCapture?.captureRef) {
-                evt.argsValueCapture = argsValueCapture.captureRef;
+            if (!__FULL_VALUE_CAPTURE_ENABLED && traceInlineValueExceedsLimit(pending.argsRaw)) {
+                evt.args = makeOmittedValue('inline-size-limit');
+            } else {
+                const argsMaterialized = await materializeTracePrivacyValueAsync(
+                    'trace.args',
+                    sanitizeTraceArgsForPrivacy(pending.argsRaw),
+                    params.cfg,
+                    params.maskReq,
+                    candidate,
+                    params.masking,
+                    activePrivacy,
+                );
+                evt.args = limitMaterializedTraceInlineValue(argsMaterialized);
+                const argsValueCapture = await maybeCaptureTraceValueAsync({
+                    target: 'trace.args',
+                    rawValue: pending.argsRaw,
+                    previewValue: evt.args,
+                    capture: captureContext,
+                    metadata: traceValueMetadata,
+                });
+                if (argsValueCapture?.entry) {
+                    attachTraceValueEntry(evt, argsValueCapture.entry);
+                }
+                if (argsValueCapture?.captureRef) {
+                    evt.argsValueCapture = argsValueCapture.captureRef;
+                }
             }
         }
         if (!omitJsonBuiltinValues && pending.returnValueRaw !== undefined) {
-            const returnValueMaterialized = await materializeTracePrivacyValueAsync(
-                'trace.returnValue',
-                sanitizeTraceValueForPrivacy(pending.returnValueRaw),
-                params.cfg,
-                params.maskReq,
-                candidate,
-                params.masking,
-                activePrivacy,
-            );
-            evt.returnValue = limitMaterializedTraceInlineValue(returnValueMaterialized);
-            const returnValueCapture = await maybeCaptureTraceValueAsync({
-                target: 'trace.returnValue',
-                rawValue: pending.returnValueRaw,
-                previewValue: evt.returnValue,
-                capture: captureContext,
-                metadata: traceValueMetadata,
-            });
-            if (returnValueCapture?.entry) {
-                attachTraceValueEntry(evt, returnValueCapture.entry);
-            }
-            if (returnValueCapture?.captureRef) {
-                evt.returnValueCapture = returnValueCapture.captureRef;
+            if (!__FULL_VALUE_CAPTURE_ENABLED && traceInlineValueExceedsLimit(pending.returnValueRaw)) {
+                evt.returnValue = makeOmittedValue('inline-size-limit');
+            } else {
+                const returnValueMaterialized = await materializeTracePrivacyValueAsync(
+                    'trace.returnValue',
+                    sanitizeTraceValueForPrivacy(pending.returnValueRaw),
+                    params.cfg,
+                    params.maskReq,
+                    candidate,
+                    params.masking,
+                    activePrivacy,
+                );
+                evt.returnValue = limitMaterializedTraceInlineValue(returnValueMaterialized);
+                const returnValueCapture = await maybeCaptureTraceValueAsync({
+                    target: 'trace.returnValue',
+                    rawValue: pending.returnValueRaw,
+                    previewValue: evt.returnValue,
+                    capture: captureContext,
+                    metadata: traceValueMetadata,
+                });
+                if (returnValueCapture?.entry) {
+                    attachTraceValueEntry(evt, returnValueCapture.entry);
+                }
+                if (returnValueCapture?.captureRef) {
+                    evt.returnValueCapture = returnValueCapture.captureRef;
+                }
             }
         }
         if (pending.errorRaw !== undefined) {
-            const errorMaterialized = await materializeTracePrivacyValueAsync(
-                'trace.error',
-                sanitizeTraceValueForPrivacy(pending.errorRaw),
-                params.cfg,
-                params.maskReq,
-                candidate,
-                params.masking,
-                activePrivacy,
-            );
-            evt.error = limitMaterializedTraceInlineValue(errorMaterialized);
-            const errorValueCapture = await maybeCaptureTraceValueAsync({
-                target: 'trace.error',
-                rawValue: pending.errorRaw,
-                previewValue: evt.error,
-                capture: captureContext,
-                metadata: traceValueMetadata,
-            });
-            if (errorValueCapture?.entry) {
-                attachTraceValueEntry(evt, errorValueCapture.entry);
-            }
-            if (errorValueCapture?.captureRef) {
-                evt.errorValueCapture = errorValueCapture.captureRef;
+            if (!__FULL_VALUE_CAPTURE_ENABLED && traceInlineValueExceedsLimit(pending.errorRaw)) {
+                evt.error = makeOmittedValue('inline-size-limit');
+            } else {
+                const errorMaterialized = await materializeTracePrivacyValueAsync(
+                    'trace.error',
+                    sanitizeTraceValueForPrivacy(pending.errorRaw),
+                    params.cfg,
+                    params.maskReq,
+                    candidate,
+                    params.masking,
+                    activePrivacy,
+                );
+                evt.error = limitMaterializedTraceInlineValue(errorMaterialized);
+                const errorValueCapture = await maybeCaptureTraceValueAsync({
+                    target: 'trace.error',
+                    rawValue: pending.errorRaw,
+                    previewValue: evt.error,
+                    capture: captureContext,
+                    metadata: traceValueMetadata,
+                });
+                if (errorValueCapture?.entry) {
+                    attachTraceValueEntry(evt, errorValueCapture.entry);
+                }
+                if (errorValueCapture?.captureRef) {
+                    evt.errorValueCapture = errorValueCapture.captureRef;
+                }
             }
         }
     }
@@ -3405,7 +3438,24 @@ function limitInlinePrivacyValue(
     target: RuntimePrivacySurface,
     value: any,
 ): InlinePrivacyMaterializationResult {
-    void target;
+    if (value === undefined) {
+        return { value };
+    }
+
+    const serialized = boundedSerializedTraceValueLength(value, TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS);
+    if (serialized.exceeded) {
+        return {
+            value: undefined,
+            skipped: {
+                status: 'skipped',
+                reason: 'inline-size-limit',
+                target,
+                serializedLength: Math.max(serialized.length, TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS + 1),
+                limit: TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS,
+            },
+        };
+    }
+
     return { value };
 }
 
@@ -4459,11 +4509,15 @@ function chunkTraceEventsForTransport(
 ): TraceEventRecord[][] {
     if (!Array.isArray(events) || events.length === 0) return [];
 
-    const countBatches = chunkArray(events, TRACE_BATCH_SIZE);
+    const boundedEvents = events.slice(0, TRACE_MAX_EVENTS_PER_REQUEST);
+    const countBatches = chunkArray(boundedEvents, TRACE_BATCH_SIZE);
     const sizedBatches: TraceEventRecord[][] = [];
     let current: TraceEventRecord[] = [];
 
     for (const event of countBatches.flat()) {
+        if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
+            break;
+        }
         const candidate = current.concat(event);
         const batchIndex = sizedBatches.length;
         const estimatedBytes = estimateTraceBatchSerializedBytes(
@@ -4478,6 +4532,10 @@ function chunkTraceEventsForTransport(
             estimatedBytes > TRACE_BATCH_MAX_SERIALIZED_BYTES
         ) {
             sizedBatches.push(current);
+            if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
+                current = [];
+                break;
+            }
             current = [event];
             continue;
         }
@@ -4485,7 +4543,10 @@ function chunkTraceEventsForTransport(
         current = candidate;
     }
 
-    if (current.length > 0) {
+    if (
+        current.length > 0 &&
+        sizedBatches.length < TRACE_MAX_BATCHES_PER_REQUEST
+    ) {
         sizedBatches.push(current);
     }
 

package/test/circular-capture.test.js

@@ -1,6 +1,7 @@
 process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
 process.env.TRACE_IDLE_FLUSH_MS = '25';
 process.env.SESSION_DRAIN_TIMEOUT_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
 
 const assert = require('assert');
 const { EventEmitter } = require('events');

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

@@ -0,0 +1,189 @@
+delete process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS;
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS = '2048';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const { initReproTracing, reproMiddleware, __reproTestHooks } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 2500) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(20);
+    }
+    assert(predicate(), 'timed out waiting for expected condition');
+}
+
+function makeReqRes(sessionId, actionId, path = '/captured') {
+    const req = new EventEmitter();
+    req.method = 'GET';
+    req.url = path;
+    req.headers = sessionId && actionId
+        ? {
+            'x-bug-session-id': sessionId,
+            'x-bug-action-id': actionId,
+            'x-bug-request-start': String(Date.now()),
+        }
+        : {};
+    req.body = undefined;
+    req.params = {};
+    req.query = {};
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => 'application/json';
+    res.setHeader = () => {};
+    res.json = function (body) { this.body = body; this.emit('finish'); return body; };
+    res.send = function (body) { this.body = body; this.emit('finish'); return body; };
+    res.write = () => true;
+    res.end = () => { res.emit('finish'); return true; };
+
+    return { req, res };
+}
+
+async function invokeMiddleware(middleware, req, res, handler) {
+    await new Promise((resolve, reject) => {
+        void middleware(req, res, async (err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            try {
+                await handler();
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+function eventsOf(posts, eventType) {
+    return flattenEvents(posts).filter((event) => event?.event_type === eventType);
+}
+
+function largePayload() {
+    return {
+        rows: Array.from({ length: 400 }, (_, index) => ({
+            index,
+            depot: `depot-${index}`,
+            description: `large response row ${index} `.repeat(4),
+        })),
+    };
+}
+
+async function main() {
+    const capturedBodies = [];
+    const originalFetch = global.fetch;
+    global.fetch = async (_url, init = {}) => {
+        capturedBodies.push(JSON.parse(String(init.body || '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    try {
+        const cfg = {
+            tenantId: 'TENANT_test',
+            appId: 'APP_test',
+            appSecret: 'secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev' },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+        const middleware = reproMiddleware(cfg);
+
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const held = makeReqRes(null, null, '/held-open');
+        await invokeMiddleware(middleware, held.req, held.res, async () => {
+            // Keep one app endpoint open. Background capture from other requests must not run.
+        });
+
+        const tagged = makeReqRes('S_perf_regression', 'A_perf_regression');
+        await invokeMiddleware(middleware, tagged.req, tagged.res, async () => {
+            tagged.res.json({ ok: true });
+        });
+
+        await sleep(2200);
+        assert.equal(
+            eventsOf(capturedBodies, 'backend_request').length,
+            0,
+            `background request capture ran while a client endpoint was still active: ${JSON.stringify(capturedBodies)}`,
+        );
+
+        held.res.emit('finish');
+        await waitFor(() => eventsOf(capturedBodies, 'backend_request').length === 1);
+
+        capturedBodies.length = 0;
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        initReproTracing({ instrument: false, logFunctionCalls: false });
+
+        function largeTraceReturn() {
+            return largePayload();
+        }
+
+        const large = makeReqRes('S_perf_large_payload', 'A_perf_large_payload', '/large-payload');
+        await invokeMiddleware(middleware, large.req, large.res, async () => {
+            const traced = global.__repro_call(
+                largeTraceReturn,
+                null,
+                [],
+                'app',
+                1,
+                'largeTraceReturn',
+                false,
+            );
+            large.res.json(traced);
+        });
+
+        await waitFor(() => eventsOf(capturedBodies, 'backend_request').length === 1);
+        await waitFor(() => eventsOf(capturedBodies, 'trace_batch').length >= 1);
+
+        const backendRequest = eventsOf(capturedBodies, 'backend_request')[0]?.payload?.request;
+        assert(backendRequest, JSON.stringify(capturedBodies));
+        assert.equal(backendRequest.respBody, undefined, JSON.stringify(backendRequest));
+        assert.equal(
+            backendRequest.respBodyMaterialization?.reason,
+            'inline-size-limit',
+            JSON.stringify(backendRequest),
+        );
+
+        const traceEvents = eventsOf(capturedBodies, 'trace_batch')
+            .flatMap((event) => Array.isArray(event?.payload?.trace) ? event.payload.trace : []);
+        const largeReturnExit = traceEvents.find((event) =>
+            event?.fn === 'largeTraceReturn' &&
+            event?.type === 'exit' &&
+            event?.returnValue,
+        );
+        assert(largeReturnExit, JSON.stringify(traceEvents));
+        assert.deepEqual(
+            largeReturnExit.returnValue,
+            { __kind: 'omitted', reason: 'inline-size-limit' },
+        );
+
+        console.log('client performance regression guards OK');
+    } finally {
+        await flushIngestQueue();
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        global.fetch = originalFetch;
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/disable-subtree.test.js

@@ -2,6 +2,7 @@
 process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
 process.env.TRACE_IDLE_FLUSH_MS = '25';
 process.env.SESSION_DRAIN_TIMEOUT_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
 
 const assert = require('assert');
 const { EventEmitter } = require('events');

package/test/express-trace-http-args.test.js

@@ -1,6 +1,8 @@
 const assert = require('assert');
 const http = require('http');
 
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
+
 const originalFetch = global.fetch;
 const capturedBodies = [];
 

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

@@ -1,5 +1,6 @@
 const assert = require('assert');
 process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
 
 const { EventEmitter } = require('events');
 const { normalizeRuntimePrivacyPolicy } = require('../dist/privacy');
@@ -306,7 +307,7 @@ async function testKafkaTraceFlushIsNotBlockedForeverByActiveHttpRequest() {
     }
 }
 
-async function testLargeHttpResponseBodyIsCapturedWithoutDroppingRequest() {
+async function testLargeHttpResponseBodyKeepsRequestMetadataWithoutInlineBody() {
     const marker = 'OVERSIZED_HTTP_RESPONSE_MARKER';
     const capturedBodies = [];
     const originalFetch = global.fetch;
@@ -341,13 +342,15 @@ async function testLargeHttpResponseBodyIsCapturedWithoutDroppingRequest() {
         await waitFor(() => capturedBodies.some((body) => {
             const text = JSON.stringify(body);
             return text.includes('"event_type":"backend_request"') &&
-                text.includes(marker);
+                text.includes('"reason":"inline-size-limit"');
         }));
         const text = JSON.stringify(capturedBodies);
-        assert(text.includes(marker), text);
-        assert(!text.includes('respBodyMaterialization'), text);
-        assert(!text.includes('inline_value_omitted_too_large'), text);
-        assertNoLargeJsonPreviewArtifacts(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);
     } finally {
         await flushIngestQueue();
         global.fetch = originalFetch;
@@ -743,7 +746,7 @@ async function main() {
     await testKafkaConsumerTraceUsesConsumeTraceId();
     await testKafkaProducerCapturesFullPublishedMessageValue();
     await testKafkaTraceFlushIsNotBlockedForeverByActiveHttpRequest();
-    await testLargeHttpResponseBodyIsCapturedWithoutDroppingRequest();
+    await testLargeHttpResponseBodyKeepsRequestMetadataWithoutInlineBody();
     await testJsonBuiltinTracePayloadsAreOmitted();
     await testLargeStringTraceValuesStayIngestibleAndCaptureFullValueOutOfBand();
     await testLargeStructuredTraceValuesStayIngestibleAndCaptureFullValueOutOfBand();

package/test/request-flush-timing.test.js

@@ -1,4 +1,5 @@
 process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
 
 const assert = require('assert');
 const { EventEmitter } = require('events');

package/test/trace-batch-size.test.js

@@ -37,6 +37,10 @@ function main() {
     );
 
     assert(batches.length > 1, `expected more than one batch, got ${batches.length}`);
+    assert(
+        batches.length <= 8,
+        `expected trace transport to cap batches per request, got ${batches.length}`,
+    );
 
     batches.forEach((batch, index) => {
         const size = __reproTestHooks.estimateTraceBatchSerializedBytesForTest(
@@ -51,6 +55,18 @@ function main() {
         );
     });
 
+    const manyEvents = Array.from({ length: 1500 }, (_, index) => makeEvent(index, 'tiny'));
+    const cappedBatches = __reproTestHooks.chunkTraceEventsForTransportForTest(
+        manyEvents,
+        'RID_test_trace_event_cap',
+        'A_test_trace_event_cap',
+    );
+    const cappedEventCount = cappedBatches.reduce((sum, batch) => sum + batch.length, 0);
+    assert(
+        cappedEventCount <= 1000,
+        `expected trace transport to cap events per request, got ${cappedEventCount}`,
+    );
+
     // eslint-disable-next-line no-console
     console.log('trace batch size chunking OK');
 }