@reproapp/node-sdk 0.0.5 → 0.0.7

package/dist/index.js

@@ -736,6 +736,9 @@ function traceEventCandidateFromRecord(event) {
         library: inferLibraryNameFromFile(sourceFileForLibrary ?? event.file),
     };
 }
+function shouldOmitJsonBuiltinTraceValues(event) {
+    return event.fn === 'JSON.parse' || event.fn === 'JSON.stringify';
+}
 function preparePendingTraceEventsForFlush(events) {
     const prepared = [];
     const excludedSpanIds = new Set();
@@ -755,6 +758,13 @@ function preparePendingTraceEventsForFlush(events) {
         }
         if (event.__reproPending) {
             event.__reproPending.candidate = candidate;
+            if (shouldOmitJsonBuiltinTraceValues(candidate)) {
+                delete event.__reproPending.argsRaw;
+                delete event.__reproPending.returnValueRaw;
+                if (event.__reproPending.errorRaw === undefined) {
+                    delete event.__reproPending;
+                }
+            }
         }
         delete event.__reproSourceFile;
         prepared.push(event);
@@ -807,6 +817,12 @@ const SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = (() => {
         return env;
     return 1000;
 })();
+const SDK_BACKGROUND_MAX_DEFER_MS = (() => {
+    const env = Number(process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS);
+    if (Number.isFinite(env) && env >= 0)
+        return Math.trunc(env);
+    return 2000;
+})();
 const SDK_BACKGROUND_WORK_TIMEOUT_MS = (() => {
     const env = Number(process.env.REPRO_SDK_BACKGROUND_WORK_TIMEOUT_MS);
     if (Number.isFinite(env) && env >= 0)
@@ -844,6 +860,7 @@ const TRACE_MATERIALIZE_WORKER_IDLE_SHUTDOWN_MS = (() => {
     return 500;
 })();
 let activeClientRequestCount = 0;
+let oldestActiveClientRequestAt = null;
 let lastClientActivityAt = 0;
 let sdkBackgroundQuietUntil = 0;
 const sdkBackgroundQueue = [];
@@ -863,6 +880,12 @@ function noteClientActivity(now = Date.now()) {
 }
 function getSdkBackgroundDelayMs(now = Date.now()) {
     if (hasActiveClientRequests()) {
+        if (oldestActiveClientRequestAt !== null && 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));
+        }
         return SDK_BACKGROUND_IDLE_DELAY_MS;
     }
     const sinceLastActivity = now - lastClientActivityAt;
@@ -1077,12 +1100,21 @@ function shouldOffloadPendingTraceEvents(events) {
         const pending = event.__reproPending;
         if (!pending)
             continue;
-        if (pending.argsRaw !== undefined)
+        if (pending.argsRaw !== undefined) {
+            if (traceInlineValueExceedsLimit(pending.argsRaw))
+                return false;
             pendingValueCount += 1;
-        if (pending.returnValueRaw !== undefined)
+        }
+        if (pending.returnValueRaw !== undefined) {
+            if (traceInlineValueExceedsLimit(pending.returnValueRaw))
+                return false;
             pendingValueCount += 1;
-        if (pending.errorRaw !== undefined)
+        }
+        if (pending.errorRaw !== undefined) {
+            if (traceInlineValueExceedsLimit(pending.errorRaw))
+                return false;
             pendingValueCount += 1;
+        }
         if (pendingValueCount >= TRACE_MATERIALIZE_OFFTHREAD_MIN_VALUES) {
             return true;
         }
@@ -1095,6 +1127,9 @@ function beginClientRequest() {
         sdkBackgroundQuietUntil = Math.max(sdkBackgroundQuietUntil, now + SDK_BACKGROUND_BUSY_IDLE_DELAY_MS);
     }
     noteClientActivity(now);
+    if (activeClientRequestCount === 0) {
+        oldestActiveClientRequestAt = now;
+    }
     activeClientRequestCount += 1;
     if (sdkBackgroundTimer) {
         try {
@@ -1108,6 +1143,7 @@ function endClientRequest() {
     activeClientRequestCount = Math.max(0, activeClientRequestCount - 1);
     noteClientActivity();
     if (!hasActiveClientRequests()) {
+        oldestActiveClientRequestAt = null;
         (0, client_1.kickIngestQueueDrain)();
         if (sdkBackgroundTimer) {
             try {
@@ -1609,26 +1645,17 @@ const TRACE_VALUE_MAX_DEPTH = 3;
 const TRACE_VALUE_MAX_KEYS = 20;
 const TRACE_VALUE_MAX_ITEMS = 20;
 const TRACE_VALUE_MAX_STRING = 2000;
-const TRACE_FULL_VALUE_MAX_DEPTH = 8;
-const TRACE_FULL_VALUE_MAX_KEYS = 200;
-const TRACE_FULL_VALUE_MAX_ITEMS = 200;
-const TRACE_FULL_VALUE_MAX_STRING = 32000;
-const TRACE_FULL_VALUE_FALLBACK_DEPTH = 6;
-const TRACE_FULL_VALUE_FALLBACK_KEYS = 100;
-const TRACE_FULL_VALUE_FALLBACK_ITEMS = 100;
-const TRACE_FULL_VALUE_FALLBACK_STRING = 8000;
-const TRACE_FULL_VALUE_MAX_SERIALIZED_CHARS = 128 * 1024;
-const INLINE_PRIVACY_MAX_SERIALIZED_CHARS = (() => {
-    const env = Number(process.env.REPRO_SDK_INLINE_PRIVACY_MAX_SERIALIZED_CHARS);
+const TRACE_FULL_VALUE_MAX_DEPTH = Number.MAX_SAFE_INTEGER;
+const TRACE_FULL_VALUE_MAX_KEYS = Number.MAX_SAFE_INTEGER;
+const TRACE_FULL_VALUE_MAX_ITEMS = Number.MAX_SAFE_INTEGER;
+const TRACE_FULL_VALUE_MAX_STRING = Number.MAX_SAFE_INTEGER;
+const TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS = (() => {
+    const env = Number(process.env.REPRO_SDK_TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS);
     if (Number.isFinite(env) && env > 0)
         return Math.trunc(env);
     return 8 * 1024;
 })();
-const INLINE_PRIVACY_PREVIEW_MAX_DEPTH = 3;
-const INLINE_PRIVACY_PREVIEW_MAX_KEYS = 12;
-const INLINE_PRIVACY_PREVIEW_MAX_ITEMS = 12;
-const INLINE_PRIVACY_PREVIEW_MAX_STRING = 512;
-const INLINE_PRIVACY_PREVIEW_JSON_PARSE_MAX_CHARS = 128 * 1024;
+const TRACE_VALUE_SIZE_EXCEEDED = Symbol('trace-value-size-exceeded');
 const TRACE_BATCH_SIZE = 100;
 const TRACE_FLUSH_DELAY_MS = 20;
 // Choose how to order trace events in payloads.
@@ -1954,7 +1981,7 @@ function sanitizeTraceValue(value, depth = 0, seen = new WeakMap(), options = {}
     if (existingPath)
         return circularReference(existingPath);
     seen.set(value, valuePath);
-    if (depth >= TRACE_VALUE_MAX_DEPTH) {
+    if (!options.disableTruncation && depth >= TRACE_VALUE_MAX_DEPTH) {
         const shallow = safeJson(value);
         if (shallow !== undefined) {
             return shallow;
@@ -1965,9 +1992,10 @@ function sanitizeTraceValue(value, depth = 0, seen = new WeakMap(), options = {}
             : { __truncated: `depth>${TRACE_VALUE_MAX_DEPTH}` };
     }
     if (Array.isArray(value)) {
-        const out = value.slice(0, TRACE_VALUE_MAX_ITEMS)
+        const sourceItems = options.disableTruncation ? value : value.slice(0, TRACE_VALUE_MAX_ITEMS);
+        const out = sourceItems
             .map((item, index) => sanitizeTraceValue(item, depth + 1, seen, options, childCapturePath(valuePath, index)));
-        if (value.length > TRACE_VALUE_MAX_ITEMS) {
+        if (!options.disableTruncation && value.length > TRACE_VALUE_MAX_ITEMS) {
             out.push(`…(${value.length - TRACE_VALUE_MAX_ITEMS} more items)`);
         }
         return out;
@@ -1976,13 +2004,13 @@ function sanitizeTraceValue(value, depth = 0, seen = new WeakMap(), options = {}
         const out = {};
         let index = 0;
         for (const [k, v] of value) {
-            if (index >= TRACE_VALUE_MAX_ITEMS)
+            if (!options.disableTruncation && index >= TRACE_VALUE_MAX_ITEMS)
                 break;
             const key = normalizeCollectionKeyForCapture(k, index);
             out[key] = sanitizeTraceValue(v, depth + 1, seen, options, childCapturePath(valuePath, key));
             index += 1;
         }
-        if (value.size > TRACE_VALUE_MAX_ITEMS) {
+        if (!options.disableTruncation && value.size > TRACE_VALUE_MAX_ITEMS) {
             out.__truncatedEntries = value.size - TRACE_VALUE_MAX_ITEMS;
         }
         return out;
@@ -1990,11 +2018,11 @@ function sanitizeTraceValue(value, depth = 0, seen = new WeakMap(), options = {}
     if (value instanceof Set) {
         const arr = [];
         for (const item of value) {
-            if (arr.length >= TRACE_VALUE_MAX_ITEMS)
+            if (!options.disableTruncation && arr.length >= TRACE_VALUE_MAX_ITEMS)
                 break;
             arr.push(sanitizeTraceValue(item, depth + 1, seen, options, childCapturePath(valuePath, arr.length)));
         }
-        if (value.size > TRACE_VALUE_MAX_ITEMS) {
+        if (!options.disableTruncation && value.size > TRACE_VALUE_MAX_ITEMS) {
             arr.push(`…(${value.size - TRACE_VALUE_MAX_ITEMS} more items)`);
         }
         return arr;
@@ -2002,7 +2030,8 @@ function sanitizeTraceValue(value, depth = 0, seen = new WeakMap(), options = {}
     const ctor = value?.constructor?.name;
     const result = {};
     const keys = Object.keys(value);
-    for (const key of keys.slice(0, TRACE_VALUE_MAX_KEYS)) {
+    const visibleKeys = options.disableTruncation ? keys : keys.slice(0, TRACE_VALUE_MAX_KEYS);
+    for (const key of visibleKeys) {
         try {
             result[key] = sanitizeTraceValue(value[key], depth + 1, seen, options, childCapturePath(valuePath, key));
         }
@@ -2010,7 +2039,7 @@ function sanitizeTraceValue(value, depth = 0, seen = new WeakMap(), options = {}
             result[key] = `[Cannot serialize: ${err?.message || 'unknown error'}]`;
         }
     }
-    if (keys.length > TRACE_VALUE_MAX_KEYS) {
+    if (!options.disableTruncation && keys.length > TRACE_VALUE_MAX_KEYS) {
         result.__truncatedKeys = keys.length - TRACE_VALUE_MAX_KEYS;
     }
     if (ctor && ctor !== 'Object') {
@@ -2024,7 +2053,10 @@ function sanitizeTraceArgs(values) {
     return values.map((v, index) => sanitizeTraceValue(v, 0, new WeakMap(), {}, `$[${index}]`));
 }
 function sanitizeTraceValueForPrivacy(value) {
-    return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true });
+    return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
+}
+function sanitizeMaterializedTraceValue(value) {
+    return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
 }
 function sanitizeTraceArgsForPrivacy(values) {
     if (!Array.isArray(values))
@@ -2036,6 +2068,9 @@ function normalizeRawTraceArgs(values) {
         return values;
     return [values];
 }
+function hasMeaningfulRawTraceError(error) {
+    return error !== undefined && error !== null;
+}
 async function materializePendingTraceEvents(events, params) {
     for (const evt of events) {
         const pending = evt.__reproPending;
@@ -2043,74 +2078,16 @@ async function materializePendingTraceEvents(events, params) {
             continue;
         delete evt.__reproPending;
         const candidate = pending.candidate ?? traceEventCandidateFromRecord(evt);
+        const omitJsonBuiltinValues = shouldOmitJsonBuiltinTraceValues(candidate);
         const activePrivacy = params.resolvePrivacy();
-        const capture = {
-            runtimeConfig: params.cfg,
-            captureHeaders: params.cfg.captureHeaders,
-            maskReq: params.maskReq,
-            trace: candidate,
-            masking: params.masking,
-            privacy: activePrivacy,
-        };
-        if (pending.argsRaw !== undefined) {
-            const argsPreview = sanitizeTraceArgsForPrivacy(pending.argsRaw);
-            const argsMaterialization = await materializeInlinePrivacyValueAsync('trace.args', argsPreview, params.cfg, params.maskReq, candidate, params.masking, activePrivacy);
-            if (argsMaterialization.skipped) {
-                evt.argsMaterialization = argsMaterialization.skipped;
-                if (argsMaterialization.value !== undefined) {
-                    evt.args = sanitizeTraceValue(argsMaterialization.value);
-                }
-            }
-            else {
-                evt.args = sanitizeTraceValue(argsMaterialization.value);
-                evt.argsValueCapture = await maybeCaptureFullTraceValueAsync({
-                    target: 'trace.args',
-                    rawValue: pending.argsRaw,
-                    previewValue: evt.args,
-                    event: evt,
-                    capture,
-                });
-            }
+        if (!omitJsonBuiltinValues && pending.argsRaw !== undefined) {
+            evt.args = sanitizeMaterializedTraceValue(await materializeTracePrivacyValueAsync('trace.args', sanitizeTraceArgsForPrivacy(pending.argsRaw), params.cfg, params.maskReq, candidate, params.masking, activePrivacy));
         }
-        if (pending.returnValueRaw !== undefined) {
-            const returnValuePreview = sanitizeTraceValueForPrivacy(pending.returnValueRaw);
-            const returnValueMaterialization = await materializeInlinePrivacyValueAsync('trace.returnValue', returnValuePreview, params.cfg, params.maskReq, candidate, params.masking, activePrivacy);
-            if (returnValueMaterialization.skipped) {
-                evt.returnValueMaterialization = returnValueMaterialization.skipped;
-                if (returnValueMaterialization.value !== undefined) {
-                    evt.returnValue = sanitizeTraceValue(returnValueMaterialization.value);
-                }
-            }
-            else {
-                evt.returnValue = sanitizeTraceValue(returnValueMaterialization.value);
-                evt.returnValueCapture = await maybeCaptureFullTraceValueAsync({
-                    target: 'trace.returnValue',
-                    rawValue: pending.returnValueRaw,
-                    previewValue: evt.returnValue,
-                    event: evt,
-                    capture,
-                });
-            }
+        if (!omitJsonBuiltinValues && pending.returnValueRaw !== undefined) {
+            evt.returnValue = sanitizeMaterializedTraceValue(await materializeTracePrivacyValueAsync('trace.returnValue', sanitizeTraceValueForPrivacy(pending.returnValueRaw), params.cfg, params.maskReq, candidate, params.masking, activePrivacy));
         }
         if (pending.errorRaw !== undefined) {
-            const errorPreview = sanitizeTraceValueForPrivacy(pending.errorRaw);
-            const errorMaterialization = await materializeInlinePrivacyValueAsync('trace.error', errorPreview, params.cfg, params.maskReq, candidate, params.masking, activePrivacy);
-            if (errorMaterialization.skipped) {
-                evt.errorMaterialization = errorMaterialization.skipped;
-                if (errorMaterialization.value !== undefined) {
-                    evt.error = sanitizeTraceValue(errorMaterialization.value);
-                }
-            }
-            else {
-                evt.error = sanitizeTraceValue(errorMaterialization.value);
-                evt.errorValueCapture = await maybeCaptureFullTraceValueAsync({
-                    target: 'trace.error',
-                    rawValue: pending.errorRaw,
-                    previewValue: evt.error,
-                    event: evt,
-                    capture,
-                });
-            }
+            evt.error = sanitizeMaterializedTraceValue(await materializeTracePrivacyValueAsync('trace.error', sanitizeTraceValueForPrivacy(pending.errorRaw), params.cfg, params.maskReq, candidate, params.masking, activePrivacy));
         }
     }
     return events;
@@ -2120,10 +2097,6 @@ function stripPendingTraceValues(events, reason) {
         if (!evt.__reproPending)
             continue;
         delete evt.__reproPending;
-        evt.valueMaterialization = {
-            status: 'skipped',
-            reason,
-        };
     }
     return events;
 }
@@ -2203,7 +2176,7 @@ function sanitizeRequestSnapshot(value) {
     if (value === undefined)
         return undefined;
     try {
-        return sanitizeTraceValue(value);
+        return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
     }
     catch {
         if (value === null)
@@ -2396,6 +2369,21 @@ function shareRuntimePrivacyState(source, target) {
 function shouldCapturePrivacyRaw(cfg) {
     return cfg.privacy?.captureRaw === true;
 }
+function normalizeValueForRuntimePrivacy(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    try {
+        return sanitizeTraceValue(value, 0, new WeakMap(), {
+            preserveLongStrings: true,
+            disableTruncation: true,
+        });
+    }
+    catch {
+        const fallback = safeJson(value);
+        return fallback === undefined ? value : fallback;
+    }
+}
 function resolveRuntimePrivacyStartupMaxWaitMs(cfg) {
     const value = Number(cfg?.startupMaxWaitMs);
     if (!Number.isFinite(value)) {
@@ -2560,7 +2548,8 @@ function applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy,
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
-    const transformed = (0, privacy_1.applyRuntimePrivacyPolicy)(privacy, target, value, {
+    const privacyInput = normalizeValueForRuntimePrivacy(value);
+    const transformed = (0, privacy_1.applyRuntimePrivacyPolicy)(privacy, target, privacyInput, {
         routeKey: req.key,
         trace: trace
             ? {
@@ -2579,7 +2568,8 @@ async function applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
-    const transformed = await (0, privacy_1.applyRuntimePrivacyPolicyAsync)(privacy, target, value, {
+    const privacyInput = normalizeValueForRuntimePrivacy(value);
+    const transformed = await (0, privacy_1.applyRuntimePrivacyPolicyAsync)(privacy, target, privacyInput, {
         routeKey: req.key,
         trace: trace
             ? {
@@ -2594,174 +2584,43 @@ async function applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking
     });
     return applyMasking(target, transformed, req, trace, masking);
 }
-function shouldBoundInlinePrivacyTarget(target) {
-    return (target === 'request.body' ||
-        target === 'response.body' ||
-        target === 'trace.args' ||
-        target === 'trace.returnValue' ||
-        target === 'trace.error' ||
-        target === 'db.before' ||
-        target === 'db.after' ||
-        target === 'db.query' ||
-        target === 'db.resultMeta' ||
-        target === 'db.error');
-}
-function buildOversizedInlinePreview(value, depth = 0, seen = new WeakSet(), preserveScalarValue = true) {
-    if (value === null || value === undefined)
-        return value;
-    const type = typeof value;
-    if (type === 'string') {
-        if (value.length <= INLINE_PRIVACY_PREVIEW_MAX_STRING) {
-            return preserveScalarValue ? value : { __type: 'string', length: value.length };
-        }
-        const trimmed = value.trim();
-        const mayBeJson = trimmed.startsWith('{') || trimmed.startsWith('[');
-        if (mayBeJson && value.length <= INLINE_PRIVACY_PREVIEW_JSON_PARSE_MAX_CHARS) {
-            try {
-                return {
-                    __type: 'json-string',
-                    length: value.length,
-                    parsed: buildOversizedInlinePreview(JSON.parse(value), depth + 1, seen, false),
-                };
-            }
-            catch { }
-        }
-        return {
-            __type: 'string',
-            length: value.length,
-            truncated: true,
-        };
-    }
-    if (type === 'number' || type === 'boolean')
-        return preserveScalarValue ? value : { __type: type };
-    if (type === 'bigint')
-        return preserveScalarValue ? `${value.toString()}n` : { __type: 'bigint' };
-    if (type === 'symbol')
-        return preserveScalarValue ? value.toString() : { __type: 'symbol' };
-    if (type === 'function')
-        return `[Function${value.name ? ` ${value.name}` : ''}]`;
-    if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
-        return {
-            __type: Buffer.isBuffer(value) ? 'Buffer' : 'Uint8Array',
-            length: value.length,
-            preview: value.length ? Buffer.from(value).slice(0, 32).toString('hex') : '',
-        };
-    }
-    if (value instanceof Date)
-        return preserveScalarValue ? value.toISOString() : { __type: 'Date' };
-    if (value instanceof RegExp)
-        return preserveScalarValue ? value.toString() : { __type: 'RegExp' };
-    if (value instanceof Error) {
-        return {
-            __type: 'Error',
-            name: value.name,
-            message: preserveScalarValue ? value.message : { __type: 'string', length: value.message.length },
-        };
-    }
-    if (value instanceof WeakMap || value instanceof WeakSet) {
-        return { __type: getCtorName(value) || 'WeakCollection', uninspectable: true };
-    }
-    if (type !== 'object')
-        return preserveScalarValue ? String(value) : { __type: type };
-    if (seen.has(value))
-        return { __type: 'circular-reference' };
-    seen.add(value);
-    if (Array.isArray(value)) {
-        const items = value
-            .slice(0, INLINE_PRIVACY_PREVIEW_MAX_ITEMS)
-            .map((item) => buildOversizedInlinePreview(item, depth + 1, seen, true));
-        if (value.length > INLINE_PRIVACY_PREVIEW_MAX_ITEMS) {
-            items.push({ __truncatedItems: value.length - INLINE_PRIVACY_PREVIEW_MAX_ITEMS });
-        }
-        return items;
-    }
-    if (value instanceof Map) {
-        const out = { __type: 'Map', size: value.size };
-        let index = 0;
-        for (const [key, item] of value.entries()) {
-            if (index >= INLINE_PRIVACY_PREVIEW_MAX_ITEMS)
-                break;
-            out[normalizeCollectionKeyForCapture(key, index)] = buildOversizedInlinePreview(item, depth + 1, seen, false);
-            index += 1;
-        }
-        if (value.size > INLINE_PRIVACY_PREVIEW_MAX_ITEMS) {
-            out.__truncatedEntries = value.size - INLINE_PRIVACY_PREVIEW_MAX_ITEMS;
-        }
-        return out;
+function traceInlineValueExceedsLimit(value) {
+    return boundedSerializedTraceValueLength(value, TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS).exceeded;
+}
+function limitInlinePrivacyValue(target, value) {
+    void target;
+    return { value };
+}
+function limitRawInlinePrivacyValue(target, value) {
+    const limited = limitInlinePrivacyValue(target, value);
+    return limited.skipped ? limited : null;
+}
+function materializeInlinePrivacyValue(target, value, cfg, req, trace, masking, privacy, db) {
+    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+        return { value };
     }
-    if (value instanceof Set) {
-        const items = [];
-        let index = 0;
-        for (const item of value.values()) {
-            if (index >= INLINE_PRIVACY_PREVIEW_MAX_ITEMS)
-                break;
-            items.push(buildOversizedInlinePreview(item, depth + 1, seen, false));
-            index += 1;
-        }
-        if (value.size > INLINE_PRIVACY_PREVIEW_MAX_ITEMS) {
-            items.push({ __truncatedItems: value.size - INLINE_PRIVACY_PREVIEW_MAX_ITEMS });
-        }
-        return {
-            __type: 'Set',
-            size: value.size,
-            items,
-        };
+    try {
+        const valueAfterPrivacy = applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy, db);
+        return { value: valueAfterPrivacy };
     }
-    const keys = Object.keys(value);
-    const ctor = getCtorName(value);
-    if (depth >= INLINE_PRIVACY_PREVIEW_MAX_DEPTH) {
+    catch {
         return {
-            ...(ctor && ctor !== 'Object' ? { __type: ctor } : { __type: 'Object' }),
-            __keys: keys.slice(0, INLINE_PRIVACY_PREVIEW_MAX_KEYS),
-            ...(keys.length > INLINE_PRIVACY_PREVIEW_MAX_KEYS
-                ? { __truncatedKeys: keys.length - INLINE_PRIVACY_PREVIEW_MAX_KEYS }
-                : {}),
+            value: undefined,
+            skipped: {
+                status: 'skipped',
+                reason: 'inline_privacy_failed',
+                target,
+            },
         };
     }
-    const out = ctor && ctor !== 'Object' ? { __type: ctor } : {};
-    for (const key of keys.slice(0, INLINE_PRIVACY_PREVIEW_MAX_KEYS)) {
-        try {
-            out[key] = buildOversizedInlinePreview(value[key], depth + 1, seen, false);
-        }
-        catch (err) {
-            out[key] = { __type: 'uninspectable', message: err?.message || 'unknown error' };
-        }
-    }
-    if (keys.length > INLINE_PRIVACY_PREVIEW_MAX_KEYS) {
-        out.__truncatedKeys = keys.length - INLINE_PRIVACY_PREVIEW_MAX_KEYS;
-    }
-    return out;
 }
 async function materializeInlinePrivacyValueAsync(target, value, cfg, req, trace, masking, privacy, db) {
     if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
         return { value };
     }
-    if (shouldBoundInlinePrivacyTarget(target)) {
-        const serialized = stableSerializeTraceValue(value);
-        const serializedLength = serialized?.length ?? 0;
-        if (serializedLength > INLINE_PRIVACY_MAX_SERIALIZED_CHARS) {
-            let preview = buildOversizedInlinePreview(value);
-            try {
-                preview = await applyPrivacyThenMaskAsync(target, preview, cfg, req, trace, masking, privacy, db);
-            }
-            catch { }
-            return {
-                value: preview,
-                skipped: {
-                    status: 'skipped',
-                    reason: 'inline_value_too_large',
-                    target,
-                    serializedLength,
-                    limit: INLINE_PRIVACY_MAX_SERIALIZED_CHARS,
-                    preview: 'bounded',
-                },
-            };
-        }
-    }
     try {
-        return {
-            value: await applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking, privacy, db),
-        };
+        const valueAfterPrivacy = await applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking, privacy, db);
+        return { value: valueAfterPrivacy };
     }
     catch {
         return {
@@ -2774,6 +2633,18 @@ async function materializeInlinePrivacyValueAsync(target, value, cfg, req, trace
         };
     }
 }
+function materializeTracePrivacyValue(target, value, cfg, req, trace, masking, privacy) {
+    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+        return value;
+    }
+    return applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy);
+}
+async function materializeTracePrivacyValueAsync(target, value, cfg, req, trace, masking, privacy) {
+    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+        return value;
+    }
+    return applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking, privacy);
+}
 function maskWhenRequiresTrace(when) {
     return Boolean(when.fn ||
         when.functionName ||
@@ -3035,6 +2906,130 @@ function stableSerializeTraceValue(value) {
         return null;
     }
 }
+function boundedSerializedTraceValueLength(value, limit) {
+    let length = 0;
+    const seen = new WeakSet();
+    const add = (amount) => {
+        length += amount;
+        if (length > limit) {
+            throw TRACE_VALUE_SIZE_EXCEEDED;
+        }
+    };
+    const addString = (input) => {
+        if (length + input.length + 2 > limit) {
+            throw TRACE_VALUE_SIZE_EXCEEDED;
+        }
+        add(JSON.stringify(input).length);
+    };
+    const walk = (input) => {
+        if (input === undefined) {
+            addString('__undefined__');
+            return;
+        }
+        if (input === null) {
+            add(4);
+            return;
+        }
+        const inputType = typeof input;
+        if (inputType === 'string') {
+            addString(input);
+            return;
+        }
+        if (inputType === 'number' || inputType === 'boolean') {
+            add(JSON.stringify(input)?.length ?? String(input).length);
+            return;
+        }
+        if (inputType === 'bigint') {
+            addString(`${input.toString()}n`);
+            return;
+        }
+        if (inputType === 'symbol') {
+            addString(input.toString());
+            return;
+        }
+        if (inputType === 'function') {
+            addString('[Function]');
+            return;
+        }
+        if (Array.isArray(input)) {
+            add(1);
+            input.forEach((item, index) => {
+                if (index > 0)
+                    add(1);
+                walk(item);
+            });
+            add(1);
+            return;
+        }
+        if (input instanceof Map) {
+            add(1);
+            let index = 0;
+            for (const [key, item] of input.entries()) {
+                if (index > 0)
+                    add(1);
+                addString(normalizeCollectionKeyForCapture(key, index));
+                add(1);
+                walk(item);
+                index += 1;
+            }
+            add(1);
+            return;
+        }
+        if (input instanceof Set) {
+            add(1);
+            let index = 0;
+            for (const item of input.values()) {
+                if (index > 0)
+                    add(1);
+                walk(item);
+                index += 1;
+            }
+            add(1);
+            return;
+        }
+        if (input instanceof WeakMap || input instanceof WeakSet) {
+            addString(`[${getCtorName(input) || 'WeakCollection'}: uninspectable]`);
+            return;
+        }
+        if (input && typeof input === 'object') {
+            if (seen.has(input)) {
+                addString('[Circular]');
+                return;
+            }
+            seen.add(input);
+            add(1);
+            let index = 0;
+            for (const key of Object.keys(input).sort()) {
+                if (index > 0)
+                    add(1);
+                addString(key);
+                add(1);
+                try {
+                    walk(input[key]);
+                }
+                catch (err) {
+                    if (err === TRACE_VALUE_SIZE_EXCEEDED)
+                        throw err;
+                    addString(`[Cannot serialize: ${err?.message || 'unknown error'}]`);
+                }
+                index += 1;
+            }
+            add(1);
+            return;
+        }
+        addString(String(input));
+    };
+    try {
+        walk(value);
+        return { exceeded: false, length };
+    }
+    catch (err) {
+        if (err === TRACE_VALUE_SIZE_EXCEEDED) {
+            return { exceeded: true, length };
+        }
+        return { exceeded: true, length: limit + 1 };
+    }
+}
 function normalizeCollectionKeyForCapture(value, index) {
     const mongoId = coerceMongoId(value);
     if (mongoId !== null)
@@ -3496,12 +3491,6 @@ function createCapturedValueEntry(params) {
         maxItems: TRACE_FULL_VALUE_MAX_ITEMS,
         maxString: TRACE_FULL_VALUE_MAX_STRING,
     };
-    const fallbackLimits = {
-        maxDepth: TRACE_FULL_VALUE_FALLBACK_DEPTH,
-        maxKeys: TRACE_FULL_VALUE_FALLBACK_KEYS,
-        maxItems: TRACE_FULL_VALUE_FALLBACK_ITEMS,
-        maxString: TRACE_FULL_VALUE_FALLBACK_STRING,
-    };
     const buildMaskedCandidate = (limits) => {
         const projected = params.target === 'request.headers'
             ? sanitizeHeaders(params.rawValue, params.capture.captureHeaders)
@@ -3519,14 +3508,6 @@ function createCapturedValueEntry(params) {
     if (!candidateSerialized || candidateSerialized === previewSerialized) {
         return undefined;
     }
-    let truncatedForStorage = false;
-    if (candidateSerialized.length > TRACE_FULL_VALUE_MAX_SERIALIZED_CHARS) {
-        const fallback = buildMaskedCandidate(fallbackLimits);
-        if (fallback !== undefined && hasMeaningfulFullValue(fallback)) {
-            candidate = fallback;
-            truncatedForStorage = true;
-        }
-    }
     const valueId = (0, crypto_1.randomUUID)();
     const projectedKind = candidate && typeof candidate === 'object'
         ? (candidate.__kind || candidate.__type)
@@ -3535,13 +3516,13 @@ function createCapturedValueEntry(params) {
         id: valueId,
         target: params.target,
         value: candidate,
-        truncatedForStorage,
+        truncatedForStorage: false,
         projectedKind: typeof projectedKind === 'string' ? projectedKind : undefined,
         ...(params.metadata ?? {}),
     };
     return {
         captureRef: {
-            status: truncatedForStorage ? 'truncated-for-storage' : 'stored',
+            status: 'stored',
             valueId,
             projectedKind: entry.projectedKind,
         },
@@ -3557,12 +3538,6 @@ async function createCapturedValueEntryAsync(params) {
         maxItems: TRACE_FULL_VALUE_MAX_ITEMS,
         maxString: TRACE_FULL_VALUE_MAX_STRING,
     };
-    const fallbackLimits = {
-        maxDepth: TRACE_FULL_VALUE_FALLBACK_DEPTH,
-        maxKeys: TRACE_FULL_VALUE_FALLBACK_KEYS,
-        maxItems: TRACE_FULL_VALUE_FALLBACK_ITEMS,
-        maxString: TRACE_FULL_VALUE_FALLBACK_STRING,
-    };
     const buildMaskedCandidate = async (limits) => {
         const projected = params.target === 'request.headers'
             ? sanitizeHeaders(params.rawValue, params.capture.captureHeaders)
@@ -3580,14 +3555,6 @@ async function createCapturedValueEntryAsync(params) {
     if (!candidateSerialized || candidateSerialized === previewSerialized) {
         return undefined;
     }
-    let truncatedForStorage = false;
-    if (candidateSerialized.length > TRACE_FULL_VALUE_MAX_SERIALIZED_CHARS) {
-        const fallback = await buildMaskedCandidate(fallbackLimits);
-        if (fallback !== undefined && hasMeaningfulFullValue(fallback)) {
-            candidate = fallback;
-            truncatedForStorage = true;
-        }
-    }
     const valueId = (0, crypto_1.randomUUID)();
     const projectedKind = candidate && typeof candidate === 'object'
         ? (candidate.__kind || candidate.__type)
@@ -3596,83 +3563,19 @@ async function createCapturedValueEntryAsync(params) {
         id: valueId,
         target: params.target,
         value: candidate,
-        truncatedForStorage,
+        truncatedForStorage: false,
         projectedKind: typeof projectedKind === 'string' ? projectedKind : undefined,
         ...(params.metadata ?? {}),
     };
     return {
         captureRef: {
-            status: truncatedForStorage ? 'truncated-for-storage' : 'stored',
+            status: 'stored',
             valueId,
             projectedKind: entry.projectedKind,
         },
         entry,
     };
 }
-function maybeCaptureFullTraceValue(params) {
-    const result = createCapturedValueEntry({
-        target: params.target,
-        rawValue: params.rawValue,
-        previewValue: params.previewValue,
-        capture: params.capture,
-        metadata: {
-            fn: params.event.fn,
-            file: params.event.file,
-            line: params.event.line ?? null,
-            spanId: params.event.spanId ?? null,
-            parentSpanId: params.event.parentSpanId ?? null,
-        },
-    });
-    if (!result)
-        return undefined;
-    if (result.entry) {
-        const existing = params.event[TRACE_FULL_VALUE_ENTRY_SYMBOL];
-        if (Array.isArray(existing)) {
-            existing.push(result.entry);
-        }
-        else {
-            Object.defineProperty(params.event, TRACE_FULL_VALUE_ENTRY_SYMBOL, {
-                value: [result.entry],
-                enumerable: false,
-                configurable: true,
-                writable: true,
-            });
-        }
-    }
-    return result.captureRef;
-}
-async function maybeCaptureFullTraceValueAsync(params) {
-    const result = await createCapturedValueEntryAsync({
-        target: params.target,
-        rawValue: params.rawValue,
-        previewValue: params.previewValue,
-        capture: params.capture,
-        metadata: {
-            fn: params.event.fn,
-            file: params.event.file,
-            line: params.event.line ?? null,
-            spanId: params.event.spanId ?? null,
-            parentSpanId: params.event.parentSpanId ?? null,
-        },
-    });
-    if (!result)
-        return undefined;
-    if (result.entry) {
-        const existing = params.event[TRACE_FULL_VALUE_ENTRY_SYMBOL];
-        if (Array.isArray(existing)) {
-            existing.push(result.entry);
-        }
-        else {
-            Object.defineProperty(params.event, TRACE_FULL_VALUE_ENTRY_SYMBOL, {
-                value: [result.entry],
-                enumerable: false,
-                configurable: true,
-                writable: true,
-            });
-        }
-    }
-    return result.captureRef;
-}
 function maybeCaptureRequestValue(params, sink) {
     const result = createCapturedValueEntry(params);
     if (!result)
@@ -3792,6 +3695,7 @@ function reproMiddleware(cfg) {
             let idleTimer = null;
             let hardStopTimer = null;
             let flushPayload = null;
+            let requestCaptureScheduled = false;
             let sessionDrainWait = null;
             const activeSpans = new Set();
             let anonymousSpanDepth = 0;
@@ -3881,6 +3785,179 @@ function reproMiddleware(cfg) {
                 }
                 scheduleIdleFlush();
             };
+            const chooseRequestEndpoint = () => {
+                const pendingEvents = preparePendingTraceEventsForFlush(events.slice());
+                const baseEvents = balanceTraceEvents(pendingEvents.slice());
+                const orderedEvents = TRACE_ORDER_MODE === 'tree'
+                    ? reorderTraceEvents(baseEvents)
+                    : sortTraceEventsChronologically(baseEvents);
+                const summary = summarizeEndpointFromEvents(orderedEvents);
+                return {
+                    chosenEndpoint: summary.endpointTrace
+                        ?? summary.preferredAppTrace
+                        ?? summary.firstAppTrace
+                        ?? endpointTrace
+                        ?? preferredAppTrace
+                        ?? firstAppTrace
+                        ?? { fn: null, file: null, line: null, functionType: null },
+                    hasTraceEvents: orderedEvents.length > 0,
+                };
+            };
+            const buildRequestCapturePayloadAsync = async (chosenEndpoint, hasTraceEvents) => {
+                const endpointTraceCtx = (() => {
+                    if (!chosenEndpoint?.fn && !chosenEndpoint?.file)
+                        return null;
+                    return {
+                        type: 'enter',
+                        eventType: 'enter',
+                        fn: chosenEndpoint.fn ?? undefined,
+                        wrapperClass: inferWrapperClassFromFn(chosenEndpoint.fn),
+                        file: chosenEndpoint.file ?? null,
+                        line: chosenEndpoint.line ?? null,
+                        functionType: chosenEndpoint.functionType ?? null,
+                        library: inferLibraryNameFromFile(chosenEndpoint.file),
+                    };
+                })();
+                const activePrivacy = resolvePrivacy();
+                const requestBodyRaw = req.body;
+                const requestBodyMaterialization = limitRawInlinePrivacyValue('request.body', requestBodyRaw)
+                    ?? await materializeInlinePrivacyValueAsync('request.body', sanitizeRequestSnapshot(requestBodyRaw), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                const requestBody = requestBodyMaterialization.value;
+                const requestParams = await applyPrivacyThenMaskAsync('request.params', sanitizeRequestSnapshot(req.params), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                const requestQuery = await applyPrivacyThenMaskAsync('request.query', sanitizeRequestSnapshot(req.query), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                const maskedHeaders = await applyPrivacyThenMaskAsync('request.headers', requestHeaders, cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                const responseBodyMaterialization = capturedBody === undefined
+                    ? { value: undefined }
+                    : limitRawInlinePrivacyValue('response.body', capturedBody)
+                        ?? await materializeInlinePrivacyValueAsync('response.body', sanitizeRequestSnapshot(capturedBody), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                const responseBody = responseBodyMaterialization.value;
+                const requestValueEntries = [];
+                const bodyValueCapture = requestBodyMaterialization.skipped
+                    ? undefined
+                    : await maybeCaptureRequestValueAsync({
+                        target: 'request.body',
+                        rawValue: req.body,
+                        previewValue: requestBody,
+                        capture: {
+                            runtimeConfig: cfg,
+                            captureHeaders: cfg.captureHeaders,
+                            maskReq,
+                            trace: endpointTraceCtx,
+                            masking,
+                            privacy: activePrivacy,
+                        },
+                    }, requestValueEntries);
+                const paramsValueCapture = await maybeCaptureRequestValueAsync({
+                    target: 'request.params',
+                    rawValue: req.params,
+                    previewValue: requestParams,
+                    capture: {
+                        runtimeConfig: cfg,
+                        captureHeaders: cfg.captureHeaders,
+                        maskReq,
+                        trace: endpointTraceCtx,
+                        masking,
+                        privacy: activePrivacy,
+                    },
+                }, requestValueEntries);
+                const queryValueCapture = await maybeCaptureRequestValueAsync({
+                    target: 'request.query',
+                    rawValue: req.query,
+                    previewValue: requestQuery,
+                    capture: {
+                        runtimeConfig: cfg,
+                        captureHeaders: cfg.captureHeaders,
+                        maskReq,
+                        trace: endpointTraceCtx,
+                        masking,
+                        privacy: activePrivacy,
+                    },
+                }, requestValueEntries);
+                const headersValueCapture = await maybeCaptureRequestValueAsync({
+                    target: 'request.headers',
+                    rawValue: req.headers,
+                    previewValue: maskedHeaders,
+                    capture: {
+                        runtimeConfig: cfg,
+                        captureHeaders: cfg.captureHeaders,
+                        maskReq,
+                        trace: endpointTraceCtx,
+                        masking,
+                        privacy: activePrivacy,
+                    },
+                }, requestValueEntries);
+                const respBodyValueCapture = responseBodyMaterialization.skipped
+                    ? undefined
+                    : await maybeCaptureRequestValueAsync({
+                        target: 'response.body',
+                        rawValue: capturedBody,
+                        previewValue: responseBody,
+                        capture: {
+                            runtimeConfig: cfg,
+                            captureHeaders: cfg.captureHeaders,
+                            maskReq,
+                            trace: endpointTraceCtx,
+                            masking,
+                            privacy: activePrivacy,
+                        },
+                    }, requestValueEntries);
+                const requestPayload = {
+                    rid,
+                    method: req.method,
+                    url,
+                    path,
+                    status: res.statusCode,
+                    durMs: Date.now() - t0,
+                    headers: maskedHeaders,
+                    key,
+                    respBody: responseBody,
+                    trace: hasTraceEvents ? undefined : [],
+                };
+                if (requestBody !== undefined)
+                    requestPayload.body = requestBody;
+                if (bodyValueCapture)
+                    requestPayload.bodyValueCapture = bodyValueCapture;
+                if (requestParams !== undefined)
+                    requestPayload.params = requestParams;
+                if (paramsValueCapture)
+                    requestPayload.paramsValueCapture = paramsValueCapture;
+                if (requestQuery !== undefined)
+                    requestPayload.query = requestQuery;
+                if (queryValueCapture)
+                    requestPayload.queryValueCapture = queryValueCapture;
+                if (headersValueCapture)
+                    requestPayload.headersValueCapture = headersValueCapture;
+                if (respBodyValueCapture)
+                    requestPayload.respBodyValueCapture = respBodyValueCapture;
+                if (requestBodyMaterialization.skipped) {
+                    requestPayload.bodyMaterialization = requestBodyMaterialization.skipped;
+                }
+                if (responseBodyMaterialization.skipped) {
+                    requestPayload.respBodyMaterialization = responseBodyMaterialization.skipped;
+                }
+                requestPayload.entryPoint = chosenEndpoint;
+                return { requestPayload, requestValueEntries };
+            };
+            const emitRequestCaptureAsync = async () => {
+                if (requestCaptureScheduled)
+                    return;
+                requestCaptureScheduled = true;
+                try {
+                    const { chosenEndpoint, hasTraceEvents } = chooseRequestEndpoint();
+                    const { requestPayload, requestValueEntries } = await buildRequestCapturePayloadAsync(chosenEndpoint, hasTraceEvents);
+                    post(cfg, sid, {
+                        entries: [{
+                                actionId: aid,
+                                request: requestPayload,
+                                requestValues: requestValueEntries.length ? requestValueEntries : undefined,
+                                t: requestEpochMs,
+                            }]
+                    });
+                }
+                catch {
+                    // never break user code
+                }
+            };
             try {
                 if (__TRACER__?.tracer?.on) {
                     const getTid = __TRACER__?.getCurrentTraceId;
@@ -3933,7 +4010,8 @@ function reproMiddleware(cfg) {
                             if (finished) {
                                 scheduleIdleFlush();
                             }
-                            if (ev.args !== undefined || ev.returnValue !== undefined || ev.error !== undefined) {
+                            const hasErrorPayload = hasMeaningfulRawTraceError(ev.error);
+                            if (ev.args !== undefined || ev.returnValue !== undefined || hasErrorPayload) {
                                 evt.__reproPending = {
                                     ...(ev.args !== undefined
                                         ? {
@@ -3945,7 +4023,7 @@ function reproMiddleware(cfg) {
                                             returnValueRaw: ev.returnValue,
                                         }
                                         : {}),
-                                    ...(ev.error !== undefined
+                                    ...(hasErrorPayload
                                         ? {
                                             errorRaw: ev.error,
                                         }
@@ -3972,6 +4050,7 @@ function reproMiddleware(cfg) {
                         : Buffer.from(chunks.map(String).join(''));
                     capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
                 }
+                void emitRequestCaptureAsync();
                 if (!flushPayload) {
                     flushPayload = async () => {
                         try {
@@ -3986,150 +4065,7 @@ function reproMiddleware(cfg) {
                             const orderedEvents = TRACE_ORDER_MODE === 'tree'
                                 ? reorderTraceEvents(baseEvents)
                                 : sortTraceEventsChronologically(baseEvents);
-                            const summary = summarizeEndpointFromEvents(orderedEvents);
-                            const chosenEndpoint = summary.endpointTrace
-                                ?? summary.preferredAppTrace
-                                ?? summary.firstAppTrace
-                                ?? endpointTrace
-                                ?? preferredAppTrace
-                                ?? firstAppTrace
-                                ?? { fn: null, file: null, line: null, functionType: null };
                             const traceBatches = chunkArray(orderedEvents, TRACE_BATCH_SIZE);
-                            const endpointTraceCtx = (() => {
-                                if (!chosenEndpoint?.fn && !chosenEndpoint?.file)
-                                    return null;
-                                return {
-                                    type: 'enter',
-                                    eventType: 'enter',
-                                    fn: chosenEndpoint.fn ?? undefined,
-                                    wrapperClass: inferWrapperClassFromFn(chosenEndpoint.fn),
-                                    file: chosenEndpoint.file ?? null,
-                                    line: chosenEndpoint.line ?? null,
-                                    functionType: chosenEndpoint.functionType ?? null,
-                                    library: inferLibraryNameFromFile(chosenEndpoint.file),
-                                };
-                            })();
-                            const activePrivacy = resolvePrivacy();
-                            const requestBodyMaterialization = await materializeInlinePrivacyValueAsync('request.body', sanitizeRequestSnapshot(req.body), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
-                            const requestBody = requestBodyMaterialization.value;
-                            const requestParams = await applyPrivacyThenMaskAsync('request.params', sanitizeRequestSnapshot(req.params), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
-                            const requestQuery = await applyPrivacyThenMaskAsync('request.query', sanitizeRequestSnapshot(req.query), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
-                            const maskedHeaders = await applyPrivacyThenMaskAsync('request.headers', requestHeaders, cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
-                            const responseBodyMaterialization = await materializeInlinePrivacyValueAsync('response.body', capturedBody === undefined ? undefined : sanitizeRequestSnapshot(capturedBody), cfg, maskReq, endpointTraceCtx, masking, activePrivacy);
-                            const responseBody = responseBodyMaterialization.value;
-                            const requestValueEntries = [];
-                            const bodyValueCapture = requestBodyMaterialization.skipped
-                                ? undefined
-                                : await maybeCaptureRequestValueAsync({
-                                    target: 'request.body',
-                                    rawValue: req.body,
-                                    previewValue: requestBody,
-                                    capture: {
-                                        runtimeConfig: cfg,
-                                        captureHeaders: cfg.captureHeaders,
-                                        maskReq,
-                                        trace: endpointTraceCtx,
-                                        masking,
-                                        privacy: activePrivacy,
-                                    },
-                                }, requestValueEntries);
-                            const paramsValueCapture = await maybeCaptureRequestValueAsync({
-                                target: 'request.params',
-                                rawValue: req.params,
-                                previewValue: requestParams,
-                                capture: {
-                                    runtimeConfig: cfg,
-                                    captureHeaders: cfg.captureHeaders,
-                                    maskReq,
-                                    trace: endpointTraceCtx,
-                                    masking,
-                                    privacy: activePrivacy,
-                                },
-                            }, requestValueEntries);
-                            const queryValueCapture = await maybeCaptureRequestValueAsync({
-                                target: 'request.query',
-                                rawValue: req.query,
-                                previewValue: requestQuery,
-                                capture: {
-                                    runtimeConfig: cfg,
-                                    captureHeaders: cfg.captureHeaders,
-                                    maskReq,
-                                    trace: endpointTraceCtx,
-                                    masking,
-                                    privacy: activePrivacy,
-                                },
-                            }, requestValueEntries);
-                            const headersValueCapture = await maybeCaptureRequestValueAsync({
-                                target: 'request.headers',
-                                rawValue: req.headers,
-                                previewValue: maskedHeaders,
-                                capture: {
-                                    runtimeConfig: cfg,
-                                    captureHeaders: cfg.captureHeaders,
-                                    maskReq,
-                                    trace: endpointTraceCtx,
-                                    masking,
-                                    privacy: activePrivacy,
-                                },
-                            }, requestValueEntries);
-                            const respBodyValueCapture = responseBodyMaterialization.skipped
-                                ? undefined
-                                : await maybeCaptureRequestValueAsync({
-                                    target: 'response.body',
-                                    rawValue: capturedBody,
-                                    previewValue: responseBody,
-                                    capture: {
-                                        runtimeConfig: cfg,
-                                        captureHeaders: cfg.captureHeaders,
-                                        maskReq,
-                                        trace: endpointTraceCtx,
-                                        masking,
-                                        privacy: activePrivacy,
-                                    },
-                                }, requestValueEntries);
-                            const requestPayload = {
-                                rid,
-                                method: req.method,
-                                url,
-                                path,
-                                status: res.statusCode,
-                                durMs: Date.now() - t0,
-                                headers: maskedHeaders,
-                                key,
-                                respBody: responseBody,
-                                trace: traceBatches.length ? undefined : [],
-                            };
-                            if (requestBody !== undefined)
-                                requestPayload.body = requestBody;
-                            if (bodyValueCapture)
-                                requestPayload.bodyValueCapture = bodyValueCapture;
-                            if (requestParams !== undefined)
-                                requestPayload.params = requestParams;
-                            if (paramsValueCapture)
-                                requestPayload.paramsValueCapture = paramsValueCapture;
-                            if (requestQuery !== undefined)
-                                requestPayload.query = requestQuery;
-                            if (queryValueCapture)
-                                requestPayload.queryValueCapture = queryValueCapture;
-                            if (headersValueCapture)
-                                requestPayload.headersValueCapture = headersValueCapture;
-                            if (respBodyValueCapture)
-                                requestPayload.respBodyValueCapture = respBodyValueCapture;
-                            if (requestBodyMaterialization.skipped) {
-                                requestPayload.bodyMaterialization = requestBodyMaterialization.skipped;
-                            }
-                            if (responseBodyMaterialization.skipped) {
-                                requestPayload.respBodyMaterialization = responseBodyMaterialization.skipped;
-                            }
-                            requestPayload.entryPoint = chosenEndpoint;
-                            post(cfg, sid, {
-                                entries: [{
-                                        actionId: aid,
-                                        request: requestPayload,
-                                        requestValues: requestValueEntries.length ? requestValueEntries : undefined,
-                                        t: requestEpochMs,
-                                    }]
-                            });
                             if (traceBatches.length) {
                                 for (let i = 0; i < traceBatches.length; i++) {
                                     const batch = traceBatches[i];
@@ -4567,7 +4503,11 @@ function sanitizeResultForMeta(value, options = {}) {
     if (typeof value === 'function')
         return undefined;
     try {
-        return sanitizeTraceValue(value, 0, new WeakMap(), options);
+        return sanitizeTraceValue(value, 0, new WeakMap(), {
+            preserveLongStrings: true,
+            disableTruncation: true,
+            ...options,
+        });
     }
     catch {
         const fallback = safeJson(value);
@@ -4653,7 +4593,7 @@ async function emitDbQueryAsync(cfg, sid, aid, payload) {
     const afterPreview = afterMaterialization.value;
     const resultMetaMaterialization = await materializeInlinePrivacyValueAsync('db.resultMeta', resultMetaSource ?? undefined, cfg, maskReq, null, null, privacy, dbContext);
     const resultMetaPreviewRaw = resultMetaMaterialization.value;
-    const resultMetaPreview = sanitizeTraceValue(resultMetaPreviewRaw);
+    const resultMetaPreview = sanitizeMaterializedTraceValue(resultMetaPreviewRaw);
     const errorMaterialization = await materializeInlinePrivacyValueAsync('db.error', payload.error ?? undefined, cfg, maskReq, null, null, privacy, dbContext);
     const errorPreview = errorMaterialization.value;
     const capture = {
@@ -5049,23 +4989,6 @@ function normalizeKafkaHeadersForPayload(headers) {
     }
     return out;
 }
-function previewKafkaValue(value, maxLength = 120) {
-    if (value === null || value === undefined)
-        return null;
-    let text;
-    if (typeof value === 'string') {
-        text = value;
-    }
-    else if (Buffer.isBuffer(value)) {
-        text = value.toString('utf8');
-    }
-    else {
-        return null;
-    }
-    if (text.length <= maxLength)
-        return text;
-    return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
-}
 function kafkaValueSize(value) {
     if (value === null || value === undefined)
         return null;
@@ -5073,8 +4996,93 @@ function kafkaValueSize(value) {
         return Buffer.byteLength(value, 'utf8');
     if (Buffer.isBuffer(value))
         return value.length;
+    if (value instanceof Uint8Array)
+        return value.byteLength;
     return null;
 }
+function decodeKafkaValue(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'string')
+        return value;
+    if (Buffer.isBuffer(value))
+        return value.toString('utf8');
+    if (value instanceof Uint8Array)
+        return Buffer.from(value).toString('utf8');
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    return sanitizeResultForMeta(value);
+}
+function parseKafkaJsonString(value) {
+    const trimmed = value.trim();
+    if (!trimmed || !'{['.includes(trimmed[0])) {
+        return { parsed: false, value };
+    }
+    try {
+        return { parsed: true, value: JSON.parse(value) };
+    }
+    catch {
+        return { parsed: false, value };
+    }
+}
+function decodeKafkaMessageValue(value) {
+    const decoded = decodeKafkaValue(value);
+    if (typeof decoded !== 'string') {
+        return {
+            value: decoded,
+            valueEncoding: decoded === null ? null : typeof decoded,
+        };
+    }
+    const parsed = parseKafkaJsonString(decoded);
+    if (parsed.parsed) {
+        return {
+            value: parsed.value,
+            rawValue: decoded,
+            valueEncoding: 'json',
+        };
+    }
+    return {
+        value: decoded,
+        valueEncoding: 'utf8',
+    };
+}
+function buildKafkaMessagePayload(message) {
+    const msgObj = message && typeof message === 'object' ? message : { value: message };
+    const decoded = decodeKafkaMessageValue(msgObj.value);
+    const payload = {
+        key: decodeKafkaValue(msgObj.key),
+        value: decoded.value,
+        valueEncoding: decoded.valueEncoding,
+        valueBytes: kafkaValueSize(msgObj.value),
+        headers: normalizeKafkaHeadersForPayload(msgObj.headers),
+    };
+    if (decoded.rawValue !== undefined) {
+        payload.rawValue = decoded.rawValue;
+    }
+    if (msgObj.partition !== undefined) {
+        payload.partition = msgObj.partition;
+    }
+    if (msgObj.timestamp !== undefined) {
+        payload.timestamp = msgObj.timestamp;
+    }
+    if (msgObj.offset !== undefined) {
+        payload.offset = msgObj.offset;
+    }
+    return payload;
+}
+function cloneKafkaTelemetryValue(value) {
+    if (value === undefined || value === null)
+        return value;
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return value;
+    }
+}
+async function materializeKafkaRequestBody(cfg, maskReq, body) {
+    return materializeInlinePrivacyValueAsync('request.body', sanitizeTraceValueForPrivacy(body), cfg, maskReq, null, normalizeMaskingConfig(cfg.masking), getRuntimePrivacyState(cfg).policy ?? null);
+}
 function summarizeKafkaError(error) {
     const message = typeof error?.message === 'string'
         ? error.message
@@ -5150,6 +5158,7 @@ function recordKafkaTraceEvent(raw, sink, cfg, maskReq) {
     };
     if (shouldDropTraceEvent(candidate))
         return;
+    const omitJsonBuiltinValues = shouldOmitJsonBuiltinTraceValues(candidate);
     const evt = {
         t: alignTimestamp(typeof raw.t === 'number' ? raw.t : Date.now()),
         type: raw.type,
@@ -5163,14 +5172,14 @@ function recordKafkaTraceEvent(raw, sink, cfg, maskReq) {
     };
     const privacy = getRuntimePrivacyState(cfg).policy ?? null;
     const masking = normalizeMaskingConfig(cfg.masking);
-    if (raw.args !== undefined) {
-        evt.args = sanitizeTraceValue(applyPrivacyThenMask('trace.args', sanitizeTraceArgsForPrivacy(raw.args), cfg, maskReq, candidate, masking, privacy));
+    if (!omitJsonBuiltinValues && raw.args !== undefined) {
+        evt.args = sanitizeMaterializedTraceValue(materializeTracePrivacyValue('trace.args', sanitizeTraceArgsForPrivacy(raw.args), cfg, maskReq, candidate, masking, privacy));
     }
-    if (raw.returnValue !== undefined) {
-        evt.returnValue = sanitizeTraceValue(applyPrivacyThenMask('trace.returnValue', sanitizeTraceValueForPrivacy(raw.returnValue), cfg, maskReq, candidate, masking, privacy));
+    if (!omitJsonBuiltinValues && raw.returnValue !== undefined) {
+        evt.returnValue = sanitizeMaterializedTraceValue(materializeTracePrivacyValue('trace.returnValue', sanitizeTraceValueForPrivacy(raw.returnValue), cfg, maskReq, candidate, masking, privacy));
     }
-    if (raw.error !== undefined) {
-        evt.error = sanitizeTraceValue(applyPrivacyThenMask('trace.error', sanitizeTraceValueForPrivacy(raw.error), cfg, maskReq, candidate, masking, privacy));
+    if (hasMeaningfulRawTraceError(raw.error)) {
+        evt.error = sanitizeMaterializedTraceValue(materializeTracePrivacyValue('trace.error', sanitizeTraceValueForPrivacy(raw.error), cfg, maskReq, candidate, masking, privacy));
     }
     if (raw.threw !== undefined)
         evt.threw = raw.threw === true;
@@ -5197,6 +5206,7 @@ function buildPendingKafkaTraceEvent(raw) {
     };
     if (shouldDropTraceEvent(candidate))
         return null;
+    const omitJsonBuiltinValues = shouldOmitJsonBuiltinTraceValues(candidate);
     const evt = {
         t: alignTimestamp(typeof raw.t === 'number' ? raw.t : Date.now()),
         type: raw.type,
@@ -5211,19 +5221,20 @@ function buildPendingKafkaTraceEvent(raw) {
     if (typeof raw.sourceFile === 'string' && raw.sourceFile) {
         evt.__reproSourceFile = String(raw.sourceFile);
     }
-    if (raw.args !== undefined || raw.returnValue !== undefined || raw.error !== undefined) {
+    const hasErrorPayload = hasMeaningfulRawTraceError(raw.error);
+    if ((!omitJsonBuiltinValues && (raw.args !== undefined || raw.returnValue !== undefined)) || hasErrorPayload) {
         evt.__reproPending = {
-            ...(raw.args !== undefined
+            ...(!omitJsonBuiltinValues && raw.args !== undefined
                 ? {
                     argsRaw: normalizeRawTraceArgs(raw.args),
                 }
                 : {}),
-            ...(raw.returnValue !== undefined
+            ...(!omitJsonBuiltinValues && raw.returnValue !== undefined
                 ? {
                     returnValueRaw: raw.returnValue,
                 }
                 : {}),
-            ...(raw.error !== undefined
+            ...(hasErrorPayload
                 ? {
                     errorRaw: raw.error,
                 }
@@ -5351,14 +5362,26 @@ function patchKafkaProducerInstance(producer, cfg) {
             finally {
                 if (!sid)
                     return;
-                const previewKeys = propagatedMessages
-                    .slice(0, 10)
-                    .map((message) => previewKafkaValue(message?.key))
-                    .filter((value) => value !== null);
                 const totalValueBytes = propagatedMessages.reduce((sum, message) => {
                     const size = kafkaValueSize(message?.value);
                     return sum + (size ?? 0);
                 }, 0);
+                const requestKey = `KAFKA_PUBLISH ${topic}`;
+                const maskReq = {
+                    method: 'KAFKA_PUBLISH',
+                    path: `kafka://${topic}`,
+                    key: requestKey,
+                };
+                const bodyMaterialization = await materializeKafkaRequestBody(cfg, maskReq, {
+                    transport: 'kafka',
+                    topic,
+                    messageCount: propagatedMessages.length,
+                    totalValueBytes,
+                    messages: propagatedMessages.map((message) => buildKafkaMessagePayload(message)),
+                    traceId: span?.traceId ?? null,
+                    spanId: span?.spanId ?? null,
+                    parentSpanId: span?.parentSpanId ?? null,
+                });
                 const requestPayload = {
                     rid: publishRid,
                     method: 'KAFKA_PUBLISH',
@@ -5366,22 +5389,14 @@ function patchKafkaProducerInstance(producer, cfg) {
                     path: `kafka://${topic}`,
                     status: threw ? 500 : 200,
                     durMs: Date.now() - t0,
-                    key: `KAFKA_PUBLISH ${topic}`,
+                    key: requestKey,
                     headers: {
                         transport: 'kafka',
                         topic,
                         messageCount: propagatedMessages.length,
                     },
-                    body: {
-                        transport: 'kafka',
-                        topic,
-                        messageCount: propagatedMessages.length,
-                        totalValueBytes,
-                        keyPreview: previewKeys,
-                        traceId: span?.traceId ?? null,
-                        spanId: span?.spanId ?? null,
-                        parentSpanId: span?.parentSpanId ?? null,
-                    },
+                    body: bodyMaterialization.value,
+                    bodyMaterialization: bodyMaterialization.skipped,
                     respBody: threw
                         ? { error: summarizeKafkaError(error) }
                         : summarizeKafkaProducerResult(result),
@@ -5466,29 +5481,51 @@ function patchKafkaProducerInstance(producer, cfg) {
                     const count = Array.isArray(entry.messages) ? entry.messages.length : 0;
                     return sum + count;
                 }, 0);
+                const totalValueBytes = patchedTopicMessages.reduce((sum, entry) => {
+                    const messages = Array.isArray(entry.messages) ? entry.messages : [];
+                    return sum + messages.reduce((messageSum, message) => {
+                        const size = kafkaValueSize(message?.value);
+                        return messageSum + (size ?? 0);
+                    }, 0);
+                }, 0);
+                const requestKey = uniqueTopics.length === 1
+                    ? `KAFKA_PUBLISH_BATCH ${uniqueTopics[0]}`
+                    : 'KAFKA_PUBLISH_BATCH';
+                const requestPath = uniqueTopics.length === 1 ? `kafka://${uniqueTopics[0]}` : 'kafka://batch';
+                const maskReq = {
+                    method: 'KAFKA_PUBLISH_BATCH',
+                    path: requestPath,
+                    key: requestKey,
+                };
+                const bodyMaterialization = await materializeKafkaRequestBody(cfg, maskReq, {
+                    transport: 'kafka',
+                    topics: uniqueTopics,
+                    topicMessages: patchedTopicMessages.map((entry) => ({
+                        topic: sanitizeKafkaTopic(entry.topic),
+                        messages: (Array.isArray(entry.messages) ? entry.messages : [])
+                            .map((message) => buildKafkaMessagePayload(message)),
+                    })),
+                    messageCount,
+                    totalValueBytes,
+                    traceId: span?.traceId ?? null,
+                    spanId: span?.spanId ?? null,
+                    parentSpanId: span?.parentSpanId ?? null,
+                });
                 const requestPayload = {
                     rid: publishRid,
                     method: 'KAFKA_PUBLISH_BATCH',
-                    url: uniqueTopics.length === 1 ? `kafka://${uniqueTopics[0]}` : 'kafka://batch',
-                    path: uniqueTopics.length === 1 ? `kafka://${uniqueTopics[0]}` : 'kafka://batch',
+                    url: requestPath,
+                    path: requestPath,
                     status: threw ? 500 : 200,
                     durMs: Date.now() - t0,
-                    key: uniqueTopics.length === 1
-                        ? `KAFKA_PUBLISH_BATCH ${uniqueTopics[0]}`
-                        : 'KAFKA_PUBLISH_BATCH',
+                    key: requestKey,
                     headers: {
                         transport: 'kafka',
                         topicCount: uniqueTopics.length,
                         messageCount,
                     },
-                    body: {
-                        transport: 'kafka',
-                        topics: uniqueTopics,
-                        messageCount,
-                        traceId: span?.traceId ?? null,
-                        spanId: span?.spanId ?? null,
-                        parentSpanId: span?.parentSpanId ?? null,
-                    },
+                    body: bodyMaterialization.value,
+                    bodyMaterialization: bodyMaterialization.skipped,
                     respBody: threw
                         ? { error: summarizeKafkaError(error) }
                         : summarizeKafkaProducerResult(result),
@@ -5574,6 +5611,24 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
         finally {
             if (!sid)
                 return;
+            const messagePayload = buildKafkaMessagePayload(message);
+            const bodyMaterialization = await materializeKafkaRequestBody(cfg, maskReq, {
+                transport: 'kafka',
+                topic,
+                partition,
+                offset: message?.offset ?? null,
+                timestamp: message?.timestamp ?? null,
+                groupId: consumer?.__repro_group_id ?? null,
+                parentRequestRid: runtime.requestRid,
+                parentTraceId: runtime.traceId,
+                parentSpanId: runtime.parentSpanId,
+                messageKey: messagePayload.key,
+                value: cloneKafkaTelemetryValue(messagePayload.value),
+                rawValue: messagePayload.rawValue,
+                valueEncoding: messagePayload.valueEncoding,
+                valueBytes: messagePayload.valueBytes,
+                message: messagePayload,
+            });
             const requestPayload = {
                 rid: consumeRid,
                 method: 'KAFKA_CONSUME',
@@ -5583,19 +5638,8 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
                 durMs: Date.now() - t0,
                 key: `KAFKA_CONSUME ${topic}`,
                 headers: normalizeKafkaHeadersForPayload(message?.headers),
-                body: {
-                    transport: 'kafka',
-                    topic,
-                    partition,
-                    offset: message?.offset ?? null,
-                    timestamp: message?.timestamp ?? null,
-                    groupId: consumer?.__repro_group_id ?? null,
-                    parentRequestRid: runtime.requestRid,
-                    parentTraceId: runtime.traceId,
-                    parentSpanId: runtime.parentSpanId,
-                    messageKey: previewKafkaValue(message?.key),
-                    valueBytes: kafkaValueSize(message?.value),
-                },
+                body: bodyMaterialization.value,
+                bodyMaterialization: bodyMaterialization.skipped,
                 respBody: threw ? { error: summarizeKafkaError(error) } : undefined,
             };
             post(cfg, sid, {
@@ -5680,6 +5724,20 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
                 return;
             const firstOffset = messages.length ? messages[0]?.offset ?? null : null;
             const lastOffset = messages.length ? messages[messages.length - 1]?.offset ?? null : null;
+            const firstMessagePayload = firstMessage ? buildKafkaMessagePayload(firstMessage) : null;
+            const bodyMaterialization = await materializeKafkaRequestBody(cfg, maskReq, {
+                transport: 'kafka',
+                topic,
+                groupId: consumer?.__repro_group_id ?? null,
+                messageCount: messages.length,
+                firstOffset,
+                lastOffset,
+                parentRequestRid: runtime.requestRid,
+                parentTraceId: runtime.traceId,
+                parentSpanId: runtime.parentSpanId,
+                firstMessageKey: firstMessagePayload?.key ?? null,
+                messages: messages.map((message) => buildKafkaMessagePayload(message)),
+            });
             const requestPayload = {
                 rid: consumeRid,
                 method: 'KAFKA_CONSUME_BATCH',
@@ -5689,18 +5747,8 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
                 durMs: Date.now() - t0,
                 key: `KAFKA_CONSUME_BATCH ${topic}`,
                 headers: firstMessage ? normalizeKafkaHeadersForPayload(firstMessage.headers) : {},
-                body: {
-                    transport: 'kafka',
-                    topic,
-                    groupId: consumer?.__repro_group_id ?? null,
-                    messageCount: messages.length,
-                    firstOffset,
-                    lastOffset,
-                    parentRequestRid: runtime.requestRid,
-                    parentTraceId: runtime.traceId,
-                    parentSpanId: runtime.parentSpanId,
-                    firstMessageKey: firstMessage ? previewKafkaValue(firstMessage.key) : null,
-                },
+                body: bodyMaterialization.value,
+                bodyMaterialization: bodyMaterialization.skipped,
                 respBody: threw ? { error: summarizeKafkaError(error) } : undefined,
             };
             post(cfg, sid, {
@@ -6531,5 +6579,7 @@ exports.__reproTestHooks = {
         getRuntimePrivacyState(cfg).policy = policy;
     },
     recordKafkaTraceEventAsyncForTest: recordKafkaTraceEventAsync,
+    materializeInlinePrivacyValueAsyncForTest: materializeInlinePrivacyValueAsync,
+    patchKafkaProducerInstanceForTest: patchKafkaProducerInstance,
     wrapKafkaEachMessageHandlerForTest: wrapKafkaEachMessageHandler,
 };