@reproapp/node-sdk 0.0.5 → 0.0.7

package/src/index.ts

@@ -355,9 +355,6 @@ type TraceEventRecord = {
     threw?: boolean;
     error?: any;
     unawaited?: boolean;
-    argsValueCapture?: TraceValueCaptureRef;
-    returnValueCapture?: TraceValueCaptureRef;
-    errorValueCapture?: TraceValueCaptureRef;
 };
 
 type PendingTraceEventRecord = TraceEventRecord & {
@@ -390,10 +387,7 @@ type TraceValueBatchEntry = {
         | 'request.body'
         | 'request.params'
         | 'request.query'
-        | 'response.body'
-        | 'trace.args'
-        | 'trace.returnValue'
-        | 'trace.error';
+        | 'response.body';
     value: any;
     truncatedForStorage?: boolean;
     projectedKind?: string;
@@ -1094,6 +1088,10 @@ function traceEventCandidateFromRecord(event: PendingTraceEventRecord): TraceEve
     };
 }
 
+function shouldOmitJsonBuiltinTraceValues(event: TraceEventForFilter | { fn?: any }): boolean {
+    return event.fn === 'JSON.parse' || event.fn === 'JSON.stringify';
+}
+
 function preparePendingTraceEventsForFlush(events: PendingTraceEventRecord[]): PendingTraceEventRecord[] {
     const prepared: PendingTraceEventRecord[] = [];
     const excludedSpanIds = new Set<string>();
@@ -1116,6 +1114,13 @@ function preparePendingTraceEventsForFlush(events: PendingTraceEventRecord[]): P
 
         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);
@@ -1180,6 +1185,12 @@ 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);
+    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) return Math.trunc(env);
@@ -1217,6 +1228,7 @@ const TRACE_MATERIALIZE_WORKER_IDLE_SHUTDOWN_MS = (() => {
 })();
 
 let activeClientRequestCount = 0;
+let oldestActiveClientRequestAt: number | null = null;
 let lastClientActivityAt = 0;
 let sdkBackgroundQuietUntil = 0;
 const sdkBackgroundQueue: Array<() => Promise<void> | void> = [];
@@ -1243,6 +1255,11 @@ function noteClientActivity(now = Date.now()): void {
 
 function getSdkBackgroundDelayMs(now = Date.now()): number {
     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;
@@ -1433,9 +1450,18 @@ function shouldOffloadPendingTraceEvents(events: PendingTraceEventRecord[]): boo
     for (const event of events) {
         const pending = event.__reproPending;
         if (!pending) continue;
-        if (pending.argsRaw !== undefined) pendingValueCount += 1;
-        if (pending.returnValueRaw !== undefined) pendingValueCount += 1;
-        if (pending.errorRaw !== undefined) pendingValueCount += 1;
+        if (pending.argsRaw !== undefined) {
+            if (traceInlineValueExceedsLimit(pending.argsRaw)) return false;
+            pendingValueCount += 1;
+        }
+        if (pending.returnValueRaw !== undefined) {
+            if (traceInlineValueExceedsLimit(pending.returnValueRaw)) return false;
+            pendingValueCount += 1;
+        }
+        if (pending.errorRaw !== undefined) {
+            if (traceInlineValueExceedsLimit(pending.errorRaw)) return false;
+            pendingValueCount += 1;
+        }
         if (pendingValueCount >= TRACE_MATERIALIZE_OFFTHREAD_MIN_VALUES) {
             return true;
         }
@@ -1449,6 +1475,9 @@ function beginClientRequest(): void {
         sdkBackgroundQuietUntil = Math.max(sdkBackgroundQuietUntil, now + SDK_BACKGROUND_BUSY_IDLE_DELAY_MS);
     }
     noteClientActivity(now);
+    if (activeClientRequestCount === 0) {
+        oldestActiveClientRequestAt = now;
+    }
     activeClientRequestCount += 1;
     if (sdkBackgroundTimer) {
         try { clearTimeout(sdkBackgroundTimer); } catch {}
@@ -1460,6 +1489,7 @@ function endClientRequest(): void {
     activeClientRequestCount = Math.max(0, activeClientRequestCount - 1);
     noteClientActivity();
     if (!hasActiveClientRequests()) {
+        oldestActiveClientRequestAt = null;
         kickIngestQueueDrain();
         if (sdkBackgroundTimer) {
             try { clearTimeout(sdkBackgroundTimer); } catch {}
@@ -1987,25 +2017,16 @@ 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.
@@ -2208,6 +2229,7 @@ function isMongooseQueryLike(value: any): boolean {
 
 type TraceSanitizeOptions = {
     preserveLongStrings?: boolean;
+    disableTruncation?: boolean;
 };
 
 function circularReference(path?: string): Record<string, string> {
@@ -2352,7 +2374,7 @@ function sanitizeTraceValue(
     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;
@@ -2364,9 +2386,10 @@ function sanitizeTraceValue(
     }
 
     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;
@@ -2376,12 +2399,12 @@ function sanitizeTraceValue(
         const out: Record<string, any> = {};
         let index = 0;
         for (const [k, v] of value) {
-            if (index >= TRACE_VALUE_MAX_ITEMS) break;
+            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;
@@ -2390,10 +2413,10 @@ function sanitizeTraceValue(
     if (value instanceof Set) {
         const arr: any[] = [];
         for (const item of value) {
-            if (arr.length >= TRACE_VALUE_MAX_ITEMS) break;
+            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;
@@ -2402,14 +2425,15 @@ function sanitizeTraceValue(
     const ctor = value?.constructor?.name;
     const result: Record<string, any> = {};
     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 as any)[key], depth + 1, seen, options, childCapturePath(valuePath, key));
         } catch (err) {
             result[key] = `[Cannot serialize: ${(err as Error)?.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') {
@@ -2424,7 +2448,11 @@ function sanitizeTraceArgs(values: any): any {
 }
 
 function sanitizeTraceValueForPrivacy(value: any): any {
-    return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true });
+    return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
+}
+
+function sanitizeMaterializedTraceValue(value: any): any {
+    return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
 }
 
 function sanitizeTraceArgsForPrivacy(values: any): any {
@@ -2437,6 +2465,10 @@ function normalizeRawTraceArgs(values: any): any[] {
     return [values];
 }
 
+function hasMeaningfulRawTraceError(error: any): boolean {
+    return error !== undefined && error !== null;
+}
+
 async function materializePendingTraceEvents(
     events: PendingTraceEventRecord[],
     params: {
@@ -2452,96 +2484,41 @@ async function materializePendingTraceEvents(
         delete evt.__reproPending;
 
         const candidate = pending.candidate ?? traceEventCandidateFromRecord(evt);
+        const omitJsonBuiltinValues = shouldOmitJsonBuiltinTraceValues(candidate);
         const activePrivacy = params.resolvePrivacy();
-        const capture: FullValueCaptureContext = {
-            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(
+        if (!omitJsonBuiltinValues && pending.argsRaw !== undefined) {
+            evt.args = sanitizeMaterializedTraceValue(await materializeTracePrivacyValueAsync(
                 'trace.args',
-                argsPreview,
+                sanitizeTraceArgsForPrivacy(pending.argsRaw),
                 params.cfg,
                 params.maskReq,
                 candidate,
                 params.masking,
                 activePrivacy,
-            );
-            if (argsMaterialization.skipped) {
-                (evt as any).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 (pending.returnValueRaw !== undefined) {
-            const returnValuePreview = sanitizeTraceValueForPrivacy(pending.returnValueRaw);
-            const returnValueMaterialization = await materializeInlinePrivacyValueAsync(
+        if (!omitJsonBuiltinValues && pending.returnValueRaw !== undefined) {
+            evt.returnValue = sanitizeMaterializedTraceValue(await materializeTracePrivacyValueAsync(
                 'trace.returnValue',
-                returnValuePreview,
+                sanitizeTraceValueForPrivacy(pending.returnValueRaw),
                 params.cfg,
                 params.maskReq,
                 candidate,
                 params.masking,
                 activePrivacy,
-            );
-            if (returnValueMaterialization.skipped) {
-                (evt as any).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 (pending.errorRaw !== undefined) {
-            const errorPreview = sanitizeTraceValueForPrivacy(pending.errorRaw);
-            const errorMaterialization = await materializeInlinePrivacyValueAsync(
+            evt.error = sanitizeMaterializedTraceValue(await materializeTracePrivacyValueAsync(
                 'trace.error',
-                errorPreview,
+                sanitizeTraceValueForPrivacy(pending.errorRaw),
                 params.cfg,
                 params.maskReq,
                 candidate,
                 params.masking,
                 activePrivacy,
-            );
-            if (errorMaterialization.skipped) {
-                (evt as any).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,
-                });
-            }
+            ));
         }
     }
     return events;
@@ -2554,10 +2531,6 @@ function stripPendingTraceValues(
     for (const evt of events) {
         if (!evt.__reproPending) continue;
         delete evt.__reproPending;
-        (evt as any).valueMaterialization = {
-            status: 'skipped',
-            reason,
-        };
     }
     return events;
 }
@@ -2646,7 +2619,7 @@ export async function __materializePendingTraceEventsForWorker(
 function sanitizeRequestSnapshot(value: any) {
     if (value === undefined) return undefined;
     try {
-        return sanitizeTraceValue(value);
+        return sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true });
     } catch {
         if (value === null) return null;
         if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
@@ -2860,6 +2833,22 @@ function shouldCapturePrivacyRaw(cfg: ReproMiddlewareConfig): boolean {
     return cfg.privacy?.captureRaw === true;
 }
 
+function normalizeValueForRuntimePrivacy(value: any): any {
+    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?: RuntimePrivacyConfig | null): number {
     const value = Number(cfg?.startupMaxWaitMs);
     if (!Number.isFinite(value)) {
@@ -3092,7 +3081,8 @@ function applyPrivacyThenMask(
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
-    const transformed = applyRuntimePrivacyPolicy(privacy, target, value, {
+    const privacyInput = normalizeValueForRuntimePrivacy(value);
+    const transformed = applyRuntimePrivacyPolicy(privacy, target, privacyInput, {
         routeKey: req.key,
         trace: trace
             ? {
@@ -3121,7 +3111,8 @@ async function applyPrivacyThenMaskAsync(
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
-    const transformed = await applyRuntimePrivacyPolicyAsync(privacy, target, value, {
+    const privacyInput = normalizeValueForRuntimePrivacy(value);
+    const transformed = await applyRuntimePrivacyPolicyAsync(privacy, target, privacyInput, {
         routeKey: req.key,
         trace: trace
             ? {
@@ -3145,150 +3136,56 @@ type InlinePrivacyMaterializationResult = {
         target: RuntimePrivacySurface;
         serializedLength?: number;
         limit?: number;
-        preview?: 'bounded';
     };
 };
 
-function shouldBoundInlinePrivacyTarget(target: RuntimePrivacySurface): boolean {
-    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 traceInlineValueExceedsLimit(value: any): boolean {
+    return boundedSerializedTraceValueLength(value, TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS).exceeded;
 }
 
-function buildOversizedInlinePreview(
+function limitInlinePrivacyValue(
+    target: RuntimePrivacySurface,
     value: any,
-    depth: number = 0,
-    seen: WeakSet<object> = new WeakSet<object>(),
-    preserveScalarValue: boolean = true,
-): any {
-    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;
-    }
+): InlinePrivacyMaterializationResult {
+    void target;
+    return { value };
+}
 
-    if (value instanceof Map) {
-        const out: Record<string, any> = { __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 limitRawInlinePrivacyValue(
+    target: RuntimePrivacySurface,
+    value: any,
+): InlinePrivacyMaterializationResult | null {
+    const limited = limitInlinePrivacyValue(target, value);
+    return limited.skipped ? limited : null;
+}
 
-    if (value instanceof Set) {
-        const items: any[] = [];
-        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,
-        };
+function materializeInlinePrivacyValue(
+    target: RuntimePrivacySurface,
+    value: any,
+    cfg: ReproMiddlewareConfig,
+    req: MaskRequestContext,
+    trace: TraceEventForFilter | null,
+    masking: NormalizedMaskingConfig | null,
+    privacy: NormalizedRuntimePrivacyPolicy | null,
+    db?: RuntimePrivacyDbContext | null,
+): InlinePrivacyMaterializationResult {
+    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+        return { value };
     }
 
-    const keys = Object.keys(value);
-    const ctor = getCtorName(value);
-    if (depth >= INLINE_PRIVACY_PREVIEW_MAX_DEPTH) {
+    try {
+        const valueAfterPrivacy = applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy, db);
+        return { value: valueAfterPrivacy };
+    } 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: Record<string, any> = 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 as Error)?.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(
@@ -3305,32 +3202,9 @@ async function materializeInlinePrivacyValueAsync(
         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 {
             value: undefined,
@@ -3343,6 +3217,36 @@ async function materializeInlinePrivacyValueAsync(
     }
 }
 
+function materializeTracePrivacyValue(
+    target: 'trace.args' | 'trace.returnValue' | 'trace.error',
+    value: any,
+    cfg: ReproMiddlewareConfig,
+    req: MaskRequestContext,
+    trace: TraceEventForFilter | null,
+    masking: NormalizedMaskingConfig | null,
+    privacy: NormalizedRuntimePrivacyPolicy | null,
+): any {
+    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+        return value;
+    }
+    return applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy);
+}
+
+async function materializeTracePrivacyValueAsync(
+    target: 'trace.args' | 'trace.returnValue' | 'trace.error',
+    value: any,
+    cfg: ReproMiddlewareConfig,
+    req: MaskRequestContext,
+    trace: TraceEventForFilter | null,
+    masking: NormalizedMaskingConfig | null,
+    privacy: NormalizedRuntimePrivacyPolicy | null,
+): Promise<any> {
+    if (value === undefined || shouldCapturePrivacyRaw(cfg)) {
+        return value;
+    }
+    return applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking, privacy);
+}
+
 function maskWhenRequiresTrace(when: ReproMaskWhen): boolean {
     return Boolean(
         when.fn ||
@@ -3603,6 +3507,134 @@ function stableSerializeTraceValue(value: any): string | null {
     }
 }
 
+function boundedSerializedTraceValueLength(value: any, limit: number): { exceeded: boolean; length: number } {
+    let length = 0;
+    const seen = new WeakSet<object>();
+
+    const add = (amount: number) => {
+        length += amount;
+        if (length > limit) {
+            throw TRACE_VALUE_SIZE_EXCEEDED;
+        }
+    };
+
+    const addString = (input: string) => {
+        if (length + input.length + 2 > limit) {
+            throw TRACE_VALUE_SIZE_EXCEEDED;
+        }
+        add(JSON.stringify(input).length);
+    };
+
+    const walk = (input: any): void => {
+        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 as Record<string, any>)[key]);
+                } catch (err) {
+                    if (err === TRACE_VALUE_SIZE_EXCEEDED) throw err;
+                    addString(`[Cannot serialize: ${(err as Error)?.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: any, index: number): string {
     const mongoId = coerceMongoId(value);
     if (mongoId !== null) return mongoId;
@@ -4147,10 +4179,7 @@ function createCapturedValueEntry(
             | 'request.body'
             | 'request.params'
             | 'request.query'
-            | 'response.body'
-            | 'trace.args'
-            | 'trace.returnValue'
-            | 'trace.error';
+            | 'response.body';
         rawValue: any;
         previewValue: any;
         capture: FullValueCaptureContext;
@@ -4165,13 +4194,6 @@ function createCapturedValueEntry(
         maxItems: TRACE_FULL_VALUE_MAX_ITEMS,
         maxString: TRACE_FULL_VALUE_MAX_STRING,
     };
-    const fallbackLimits: FullValueCloneLimits = {
-        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: FullValueCloneLimits) => {
         const projected = params.target === 'request.headers'
             ? sanitizeHeaders(params.rawValue, params.capture.captureHeaders)
@@ -4200,15 +4222,6 @@ function createCapturedValueEntry(
         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 = randomUUID();
     const projectedKind =
         candidate && typeof candidate === 'object'
@@ -4218,13 +4231,13 @@ function createCapturedValueEntry(
         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,
         },
@@ -4245,10 +4258,7 @@ async function createCapturedValueEntryAsync(
             | 'request.body'
             | 'request.params'
             | 'request.query'
-            | 'response.body'
-            | 'trace.args'
-            | 'trace.returnValue'
-            | 'trace.error';
+            | 'response.body';
         rawValue: any;
         previewValue: any;
         capture: FullValueCaptureContext;
@@ -4263,13 +4273,6 @@ async function createCapturedValueEntryAsync(
         maxItems: TRACE_FULL_VALUE_MAX_ITEMS,
         maxString: TRACE_FULL_VALUE_MAX_STRING,
     };
-    const fallbackLimits: FullValueCloneLimits = {
-        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: FullValueCloneLimits) => {
         const projected = params.target === 'request.headers'
             ? sanitizeHeaders(params.rawValue, params.capture.captureHeaders)
@@ -4298,15 +4301,6 @@ async function createCapturedValueEntryAsync(
         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 = randomUUID();
     const projectedKind =
         candidate && typeof candidate === 'object'
@@ -4316,13 +4310,13 @@ async function createCapturedValueEntryAsync(
         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,
         },
@@ -4330,84 +4324,6 @@ async function createCapturedValueEntryAsync(
     };
 }
 
-function maybeCaptureFullTraceValue(
-    params: {
-        target: 'trace.args' | 'trace.returnValue' | 'trace.error';
-        rawValue: any;
-        previewValue: any;
-        event: TraceEventRecord;
-        capture: FullValueCaptureContext;
-    },
-): TraceValueCaptureRef | undefined {
-    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 as any)[TRACE_FULL_VALUE_ENTRY_SYMBOL] as TraceValueBatchEntry[] | undefined;
-        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: {
-        target: 'trace.args' | 'trace.returnValue' | 'trace.error';
-        rawValue: any;
-        previewValue: any;
-        event: TraceEventRecord;
-        capture: FullValueCaptureContext;
-    },
-): Promise<TraceValueCaptureRef | undefined> {
-    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 as any)[TRACE_FULL_VALUE_ENTRY_SYMBOL] as TraceValueBatchEntry[] | undefined;
-        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: {
         target: 'request.headers' | 'request.body' | 'request.params' | 'request.query' | 'response.body';
@@ -4583,6 +4499,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
             let idleTimer: NodeJS.Timeout | null = null;
 	            let hardStopTimer: NodeJS.Timeout | null = null;
             let flushPayload: null | (() => Promise<void>) = null;
+            let requestCaptureScheduled = false;
             let sessionDrainWait: Promise<void> | null = null;
             const activeSpans = new Set<string>();
             let anonymousSpanDepth = 0;
@@ -4656,6 +4573,226 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                 scheduleIdleFlush();
             };
 
+            const chooseRequestEndpoint = (): {
+                chosenEndpoint: EndpointTraceInfo;
+                hasTraceEvents: boolean;
+            } => {
+                const pendingEvents = preparePendingTraceEventsForFlush(events.slice());
+                const baseEvents = balanceTraceEvents(pendingEvents.slice() as TraceEventRecord[]);
+                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: EndpointTraceInfo,
+                hasTraceEvents: boolean,
+            ): Promise<{
+                requestPayload: Record<string, any>;
+                requestValueEntries: TraceValueBatchEntry[];
+            }> => {
+                const endpointTraceCtx: TraceEventForFilter | null = (() => {
+                    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 as any).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 as any).params),
+                    cfg,
+                    maskReq,
+                    endpointTraceCtx,
+                    masking,
+                    activePrivacy,
+                );
+                const requestQuery = await applyPrivacyThenMaskAsync(
+                    'request.query',
+                    sanitizeRequestSnapshot((req as any).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: TraceValueBatchEntry[] = [];
+                const bodyValueCapture = requestBodyMaterialization.skipped
+                    ? undefined
+                    : await maybeCaptureRequestValueAsync({
+                        target: 'request.body',
+                        rawValue: (req as any).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 as any).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 as any).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: Record<string, any> = {
+                    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 (): Promise<void> => {
+                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;
@@ -4710,7 +4847,8 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                                 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
                                         ? {
@@ -4722,7 +4860,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                                             returnValueRaw: ev.returnValue,
                                         }
                                         : {}),
-                                    ...(ev.error !== undefined
+                                    ...(hasErrorPayload
                                         ? {
                                             errorRaw: ev.error,
                                         }
@@ -4750,6 +4888,8 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                     capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
                 }
 
+                void emitRequestCaptureAsync();
+
                 if (!flushPayload) {
                     flushPayload = async () => {
                             try {
@@ -4764,184 +4904,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                                 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: TraceEventForFilter | null = (() => {
-                                    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 as any).body),
-                                    cfg,
-                                    maskReq,
-                                    endpointTraceCtx,
-                                    masking,
-                                    activePrivacy,
-                                );
-                                const requestBody = requestBodyMaterialization.value;
-                                const requestParams = await applyPrivacyThenMaskAsync(
-                                    'request.params',
-                                    sanitizeRequestSnapshot((req as any).params),
-                                    cfg,
-                                    maskReq,
-                                    endpointTraceCtx,
-                                    masking,
-                                    activePrivacy,
-                                );
-                                const requestQuery = await applyPrivacyThenMaskAsync(
-                                    'request.query',
-                                    sanitizeRequestSnapshot((req as any).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: TraceValueBatchEntry[] = [];
-                                const bodyValueCapture = requestBodyMaterialization.skipped
-                                    ? undefined
-                                    : await maybeCaptureRequestValueAsync({
-                                        target: 'request.body',
-                                        rawValue: (req as any).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 as any).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 as any).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: Record<string, any> = {
-                                    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++) {
@@ -5390,7 +5353,11 @@ function sanitizeResultForMeta(value: any, options: TraceSanitizeOptions = {}) {
     if (value === undefined) return undefined;
     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);
         return fallback === undefined ? undefined : fallback;
@@ -5471,7 +5438,7 @@ async function emitDbQueryAsync(cfg: any, sid?: string, aid?: string, 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: FullValueCaptureContext = {
@@ -5894,27 +5861,111 @@ function normalizeKafkaHeadersForPayload(headers: any): Record<string, string> {
     return out;
 }
 
-function previewKafkaValue(value: any, maxLength: number = 120): string | null {
-    if (value === null || value === undefined) return null;
-    let text: string;
-    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: any): number | null {
     if (value === null || value === undefined) return null;
     if (typeof value === 'string') return Buffer.byteLength(value, 'utf8');
     if (Buffer.isBuffer(value)) return value.length;
+    if (value instanceof Uint8Array) return value.byteLength;
     return null;
 }
 
+function decodeKafkaValue(value: any): any {
+    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: string): { parsed: true; value: any } | { parsed: false; value: string } {
+    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: any): {
+    value: any;
+    rawValue?: string;
+    valueEncoding: string | null;
+} {
+    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: any): Record<string, any> {
+    const msgObj = message && typeof message === 'object' ? message : { value: message };
+    const decoded = decodeKafkaMessageValue(msgObj.value);
+    const payload: Record<string, any> = {
+        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: any): any {
+    if (value === undefined || value === null) return value;
+    try {
+        return JSON.parse(JSON.stringify(value));
+    } catch {
+        return value;
+    }
+}
+
+async function materializeKafkaRequestBody(
+    cfg: KafkaJsPatchConfig,
+    maskReq: MaskRequestContext,
+    body: Record<string, any>,
+): Promise<InlinePrivacyMaterializationResult> {
+    return materializeInlinePrivacyValueAsync(
+        'request.body',
+        sanitizeTraceValueForPrivacy(body),
+        cfg,
+        maskReq,
+        null,
+        normalizeMaskingConfig(cfg.masking),
+        getRuntimePrivacyState(cfg).policy ?? null,
+    );
+}
+
 function summarizeKafkaError(error: any): Record<string, unknown> {
     const message =
         typeof error?.message === 'string'
@@ -6005,6 +6056,7 @@ function recordKafkaTraceEvent(
         library: inferLibraryNameFromFile(sourceFileForLibrary ?? raw.file),
     };
     if (shouldDropTraceEvent(candidate)) return;
+    const omitJsonBuiltinValues = shouldOmitJsonBuiltinTraceValues(candidate);
 
     const evt: TraceEventRecord = {
         t: alignTimestamp(typeof raw.t === 'number' ? raw.t : Date.now()),
@@ -6020,8 +6072,8 @@ function recordKafkaTraceEvent(
 
     const privacy = getRuntimePrivacyState(cfg).policy ?? null;
     const masking = normalizeMaskingConfig(cfg.masking);
-    if (raw.args !== undefined) {
-        evt.args = sanitizeTraceValue(applyPrivacyThenMask(
+    if (!omitJsonBuiltinValues && raw.args !== undefined) {
+        evt.args = sanitizeMaterializedTraceValue(materializeTracePrivacyValue(
             'trace.args',
             sanitizeTraceArgsForPrivacy(raw.args),
             cfg,
@@ -6031,8 +6083,8 @@ function recordKafkaTraceEvent(
             privacy,
         ));
     }
-    if (raw.returnValue !== undefined) {
-        evt.returnValue = sanitizeTraceValue(applyPrivacyThenMask(
+    if (!omitJsonBuiltinValues && raw.returnValue !== undefined) {
+        evt.returnValue = sanitizeMaterializedTraceValue(materializeTracePrivacyValue(
             'trace.returnValue',
             sanitizeTraceValueForPrivacy(raw.returnValue),
             cfg,
@@ -6042,8 +6094,8 @@ function recordKafkaTraceEvent(
             privacy,
         ));
     }
-    if (raw.error !== undefined) {
-        evt.error = sanitizeTraceValue(applyPrivacyThenMask(
+    if (hasMeaningfulRawTraceError(raw.error)) {
+        evt.error = sanitizeMaterializedTraceValue(materializeTracePrivacyValue(
             'trace.error',
             sanitizeTraceValueForPrivacy(raw.error),
             cfg,
@@ -6079,6 +6131,7 @@ function buildPendingKafkaTraceEvent(raw: any): PendingTraceEventRecord | null {
         library: inferLibraryNameFromFile(sourceFileForLibrary ?? raw.file),
     };
     if (shouldDropTraceEvent(candidate)) return null;
+    const omitJsonBuiltinValues = shouldOmitJsonBuiltinTraceValues(candidate);
 
     const evt: PendingTraceEventRecord = {
         t: alignTimestamp(typeof raw.t === 'number' ? raw.t : Date.now()),
@@ -6094,19 +6147,20 @@ function buildPendingKafkaTraceEvent(raw: any): PendingTraceEventRecord | null {
     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,
                 }
@@ -6251,14 +6305,26 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                 throw err;
             } finally {
                 if (!sid) return;
-                const previewKeys = propagatedMessages
-                    .slice(0, 10)
-                    .map((message: any) => previewKafkaValue(message?.key))
-                    .filter((value: string | null): value is string => value !== null);
                 const totalValueBytes = propagatedMessages.reduce((sum: number, message: any) => {
                     const size = kafkaValueSize(message?.value);
                     return sum + (size ?? 0);
                 }, 0);
+                const requestKey = `KAFKA_PUBLISH ${topic}`;
+                const maskReq: MaskRequestContext = {
+                    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: any) => buildKafkaMessagePayload(message)),
+                    traceId: span?.traceId ?? null,
+                    spanId: span?.spanId ?? null,
+                    parentSpanId: span?.parentSpanId ?? null,
+                });
 
                 const requestPayload: Record<string, any> = {
                     rid: publishRid,
@@ -6267,22 +6333,14 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                     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),
@@ -6373,30 +6431,51 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                     const count = Array.isArray(entry.messages) ? entry.messages.length : 0;
                     return sum + count;
                 }, 0);
+                const totalValueBytes = patchedTopicMessages.reduce((sum: number, entry: any) => {
+                    const messages = Array.isArray(entry.messages) ? entry.messages : [];
+                    return sum + messages.reduce((messageSum: number, message: any) => {
+                        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: MaskRequestContext = {
+                    method: 'KAFKA_PUBLISH_BATCH',
+                    path: requestPath,
+                    key: requestKey,
+                };
+                const bodyMaterialization = await materializeKafkaRequestBody(cfg, maskReq, {
+                    transport: 'kafka',
+                    topics: uniqueTopics,
+                    topicMessages: patchedTopicMessages.map((entry: any) => ({
+                        topic: sanitizeKafkaTopic(entry.topic),
+                        messages: (Array.isArray(entry.messages) ? entry.messages : [])
+                            .map((message: any) => buildKafkaMessagePayload(message)),
+                    })),
+                    messageCount,
+                    totalValueBytes,
+                    traceId: span?.traceId ?? null,
+                    spanId: span?.spanId ?? null,
+                    parentSpanId: span?.parentSpanId ?? null,
+                });
                 const requestPayload: Record<string, any> = {
                     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),
@@ -6478,6 +6557,24 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
             throw err;
         } 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: Record<string, any> = {
                 rid: consumeRid,
                 method: 'KAFKA_CONSUME',
@@ -6487,19 +6584,8 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
                 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,
             };
 
@@ -6580,6 +6666,20 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
             if (!sid) 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: any) => buildKafkaMessagePayload(message)),
+            });
             const requestPayload: Record<string, any> = {
                 rid: consumeRid,
                 method: 'KAFKA_CONSUME_BATCH',
@@ -6589,18 +6689,8 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
                 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,
             };
 
@@ -7476,5 +7566,7 @@ export const __reproTestHooks = {
         getRuntimePrivacyState(cfg).policy = policy;
     },
     recordKafkaTraceEventAsyncForTest: recordKafkaTraceEventAsync,
+    materializeInlinePrivacyValueAsyncForTest: materializeInlinePrivacyValueAsync,
+    patchKafkaProducerInstanceForTest: patchKafkaProducerInstance,
     wrapKafkaEachMessageHandlerForTest: wrapKafkaEachMessageHandler,
 };