@reproapp/node-sdk 0.0.46 → 0.0.48

package/src/index.ts

@@ -2,7 +2,7 @@ import type { Request, Response, NextFunction } from 'express';
 import type { Schema, Model, Query } from 'mongoose';
 import * as mongoose from 'mongoose';
 import { AsyncLocalStorage } from 'async_hooks';
-import { randomUUID } from 'crypto';
+import { createHmac, randomUUID } from 'crypto';
 import { createRequire } from 'module';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
@@ -28,6 +28,7 @@ import {
     type RuntimePrivacySurface,
     type RuntimePrivacyTraceContext,
 } from './privacy';
+import { projectSemanticInfrastructureValue } from './semantic-serialization';
 
 /**
  * ============================= IMPORTANT =============================
@@ -379,7 +380,11 @@ type PendingTraceEventRecord = TraceEventRecord & {
 };
 
 type TraceValueCaptureRef = {
-    status: 'stored' | 'truncated-for-storage' | 'skipped-non-meaningful';
+    status:
+        | 'stored'
+        | 'truncated-for-storage'
+        | 'skipped-non-meaningful'
+        | 'failed-policy';
     valueId?: string;
     projectedKind?: string;
 };
@@ -414,6 +419,7 @@ type TraceValueBatchEntry = {
 };
 
 type TraceMaterializationConfig = {
+    tenantId: string;
     appId: string;
     appSecret?: string;
     appName?: string;
@@ -427,6 +433,7 @@ type TraceMaterializationWorkerPayload = {
     masking: NormalizedMaskingConfig | null;
     privacy: NormalizedRuntimePrivacyPolicy | null;
     fullValueCaptureEnabled: boolean;
+    valueNamespace?: string;
 };
 
 type TraceMaterializationWorkerRequest = {
@@ -1212,20 +1219,70 @@ type RequestCaptureScopeState = {
     traceBatchCount: number;
     dbChangeCount: number;
     emailEventCount: number;
+    captureFailures: Array<{
+        stage: string;
+        target: string;
+        reason: string;
+    }>;
+    privacyMode: 'policy' | 'fallback' | 'raw';
+    privacyPolicyFingerprint?: string;
+    privacyStatementCount: number;
+    emittedValueDefinitionIds: Set<string>;
 };
 
 function createRequestCaptureScope(
     requestRid: string,
     transport: RequestCaptureScopeState['transport'],
+    cfg?: ReproMiddlewareConfig,
 ): RequestCaptureScopeState {
+    const privacy = cfg ? getRuntimePrivacyState(cfg).policy ?? null : null;
+    const privacyMode =
+        cfg && shouldCapturePrivacyRaw(cfg)
+            ? 'raw'
+            : privacy
+                ? 'policy'
+                : 'fallback';
     return {
         requestRid,
         transport,
-        backendRequestCount: 0,
+        // Every scope represents one captured transport request. This is an
+        // observed expectation, not a count of successful enqueue operations.
+        backendRequestCount: 1,
         traceBatchCount: 0,
         dbChangeCount: 0,
         emailEventCount: 0,
+        captureFailures: [],
+        privacyMode,
+        privacyPolicyFingerprint: privacy?.fingerprint,
+        privacyStatementCount: privacy?.statements.length ?? 0,
+        emittedValueDefinitionIds: new Set(),
+    };
+}
+
+function recordRequestCaptureFailure(
+    scope: RequestCaptureScopeState | null | undefined,
+    stage: string,
+    target: string,
+    reason: string,
+): void {
+    if (!scope) return;
+    const normalized = {
+        stage: String(stage || 'capture').slice(0, 80),
+        target: String(target || 'unknown').slice(0, 120),
+        reason: String(reason || 'capture_failed').slice(0, 120),
     };
+    if (
+        scope.captureFailures.some((failure) =>
+            failure.stage === normalized.stage &&
+            failure.target === normalized.target &&
+            failure.reason === normalized.reason,
+        )
+    ) {
+        return;
+    }
+    if (scope.captureFailures.length < 25) {
+        scope.captureFailures.push(normalized);
+    }
 }
 
 function buildRequestCaptureManifestPayload(
@@ -1255,6 +1312,20 @@ function buildRequestCaptureManifestPayload(
                     to: expectedTraceBatches - 1,
                 }
                 : undefined,
+        privacy: {
+            mode: scope.privacyMode,
+            status:
+                scope.captureFailures.length > 0
+                    ? 'failed'
+                    : scope.privacyMode === 'raw'
+                        ? 'bypassed'
+                        : 'applied',
+            policyFingerprint: scope.privacyPolicyFingerprint,
+            statementCount: scope.privacyStatementCount,
+        },
+        captureFailures: scope.captureFailures.length
+            ? scope.captureFailures.map((failure) => ({ ...failure }))
+            : undefined,
         closedAt,
     };
 }
@@ -1439,12 +1510,6 @@ const SDK_BACKGROUND_MAX_DEFER_MS = (() => {
     return Number.POSITIVE_INFINITY;
 })();
 
-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);
-    return 20000;
-})();
-
 const TRACE_MATERIALIZE_OFFTHREAD_ENABLED = (() => {
     const env = String(process.env.REPRO_TRACE_MATERIALIZE_OFFTHREAD || '').trim().toLowerCase();
     if (!env) return true;
@@ -1774,24 +1839,9 @@ function scheduleSdkBackgroundDrain(delayMs = 0): void {
 }
 
 async function runSdkBackgroundWork(work: () => Promise<void> | void): Promise<void> {
-    if (!Number.isFinite(SDK_BACKGROUND_WORK_TIMEOUT_MS) || SDK_BACKGROUND_WORK_TIMEOUT_MS <= 0) {
-        await work();
-        return;
-    }
-
-    let timeout: NodeJS.Timeout | null = null;
-    const workPromise = Promise.resolve()
+    await Promise.resolve()
         .then(work)
         .catch(() => undefined);
-    const timeoutPromise = new Promise<void>((resolve) => {
-        timeout = setTimeout(resolve, SDK_BACKGROUND_WORK_TIMEOUT_MS);
-        try { (timeout as any).unref?.(); } catch {}
-    });
-
-    await Promise.race([workPromise, timeoutPromise]);
-    if (timeout) {
-        try { clearTimeout(timeout); } catch {}
-    }
 }
 
 async function drainQueuedIngestBeforeBackgroundWork(): Promise<void> {
@@ -2783,7 +2833,11 @@ const TRACE_MAX_EVENTS_PER_REQUEST = (() => {
 const TRACE_MAX_BATCHES_PER_REQUEST = (() => {
     const env = Number(process.env.REPRO_TRACE_MAX_BATCHES_PER_REQUEST);
     if (Number.isFinite(env) && env > 0) return Math.trunc(env);
-    return 8;
+    // Byte-based splitting can legitimately produce one batch per event when
+    // every event owns a distinct large value. The event limit remains the
+    // hard upper bound; deriving this from the count-only batch size silently
+    // dropped otherwise valid events after ten batches.
+    return TRACE_MAX_EVENTS_PER_REQUEST;
 })();
 const TRACE_FLUSH_DELAY_MS = 20;
 // Choose how to order trace events in payloads.
@@ -3135,6 +3189,17 @@ function sanitizeTraceValue(
     const mongoPlaceholder = describeMongoPlaceholder(value);
     if (mongoPlaceholder) return mongoPlaceholder;
 
+    const semanticProjection = projectSemanticInfrastructureValue(value);
+    if (semanticProjection) {
+        return sanitizeTraceValue(
+            semanticProjection.value,
+            depth,
+            seen,
+            options,
+            valuePath,
+        );
+    }
+
     if (isThenable(value)) {
         return { __type: 'Promise', state: 'pending' };
     }
@@ -3357,6 +3422,8 @@ async function materializePendingTraceEvents(
         maskReq: MaskRequestContext;
         masking: NormalizedMaskingConfig | null;
         resolvePrivacy: () => NormalizedRuntimePrivacyPolicy | null;
+        captureScope?: RequestCaptureScopeState | null;
+        valueNamespace?: string;
     },
 ): Promise<TraceEventRecord[]> {
     for (const evt of events) {
@@ -3374,6 +3441,7 @@ async function materializePendingTraceEvents(
             trace: candidate,
             masking: params.masking,
             privacy: activePrivacy,
+            valueNamespace: params.valueNamespace,
         };
         const traceValueMetadata = {
             fn: evt.fn,
@@ -3403,7 +3471,7 @@ async function materializePendingTraceEvents(
                     previewValue: evt.args,
                     capture: captureContext,
                     metadata: traceValueMetadata,
-                });
+                }, params.captureScope);
                 if (argsValueCapture?.entry) {
                     attachTraceValueEntry(evt, argsValueCapture.entry);
                 }
@@ -3432,7 +3500,7 @@ async function materializePendingTraceEvents(
                     previewValue: evt.returnValue,
                     capture: captureContext,
                     metadata: traceValueMetadata,
-                });
+                }, params.captureScope);
                 if (returnValueCapture?.entry) {
                     attachTraceValueEntry(evt, returnValueCapture.entry);
                 }
@@ -3461,7 +3529,7 @@ async function materializePendingTraceEvents(
                     previewValue: evt.error,
                     capture: captureContext,
                     metadata: traceValueMetadata,
-                });
+                }, params.captureScope);
                 if (errorValueCapture?.entry) {
                     attachTraceValueEntry(evt, errorValueCapture.entry);
                 }
@@ -3479,7 +3547,20 @@ function stripPendingTraceValues(
     reason: string,
 ): TraceEventRecord[] {
     for (const evt of events) {
-        if (!evt.__reproPending) continue;
+        const pending = evt.__reproPending;
+        if (!pending) continue;
+        if (pending.argsRaw !== undefined) {
+            evt.args = makeOmittedValue(reason);
+            evt.argsValueCapture = { status: 'failed-policy' };
+        }
+        if (pending.returnValueRaw !== undefined) {
+            evt.returnValue = makeOmittedValue(reason);
+            evt.returnValueCapture = { status: 'failed-policy' };
+        }
+        if (pending.errorRaw !== undefined) {
+            evt.error = makeOmittedValue(reason);
+            evt.errorValueCapture = { status: 'failed-policy' };
+        }
         delete evt.__reproPending;
     }
     return events;
@@ -3496,6 +3577,8 @@ async function materializePendingTraceEventsAsync(
         maskReq: MaskRequestContext;
         masking: NormalizedMaskingConfig | null;
         resolvePrivacy: () => NormalizedRuntimePrivacyPolicy | null;
+        captureScope?: RequestCaptureScopeState | null;
+        valueNamespace?: string;
     },
 ): Promise<TraceEventRecord[]> {
     if (!events.some((evt) => evt.__reproPending)) {
@@ -3510,6 +3593,12 @@ async function materializePendingTraceEventsAsync(
                 resolvePrivacy: () => privacy,
             });
         } catch {
+            recordRequestCaptureFailure(
+                params.captureScope ?? getCtx().captureScope,
+                'privacy.trace',
+                'trace.values',
+                'main_thread_materialization_failed',
+            );
             return stripPendingTraceValues(events, 'main_thread_failed');
         }
     }
@@ -3517,6 +3606,7 @@ async function materializePendingTraceEventsAsync(
         return await materializePendingTraceEventsOffThread(events, {
             events,
             cfg: {
+                tenantId: params.cfg.tenantId,
                 appId: params.cfg.appId,
                 appSecret: params.cfg.appSecret,
                 appName: params.cfg.appName,
@@ -3526,18 +3616,27 @@ async function materializePendingTraceEventsAsync(
             masking: params.masking,
             privacy,
             fullValueCaptureEnabled: __FULL_VALUE_CAPTURE_ENABLED,
+            valueNamespace: params.valueNamespace,
         });
     } catch (err) {
-        if (isTraceMaterializerTimeoutError(err)) {
-            return stripPendingTraceValues(events, 'worker_timeout');
-        }
         try {
             return await materializePendingTraceEvents(events, {
                 ...params,
                 resolvePrivacy: () => privacy,
             });
         } catch {
-            return stripPendingTraceValues(events, 'worker_failed');
+            recordRequestCaptureFailure(
+                params.captureScope ?? getCtx().captureScope,
+                'privacy.trace',
+                'trace.values',
+                isTraceMaterializerTimeoutError(err)
+                    ? 'worker_timeout_fallback_failed'
+                    : 'worker_and_fallback_failed',
+            );
+            return stripPendingTraceValues(
+                events,
+                isTraceMaterializerTimeoutError(err) ? 'worker_timeout_fallback_failed' : 'worker_failed',
+            );
         }
     }
 }
@@ -3553,6 +3652,7 @@ export async function __materializePendingTraceEventsForWorker(
             maskReq: payload.maskReq,
             masking: payload.masking,
             resolvePrivacy: () => payload.privacy,
+            valueNamespace: payload.valueNamespace,
         });
         return materialized.map((event) => {
             const entries = getEventTraceValueEntries(event);
@@ -4137,6 +4237,7 @@ function materializeInlinePrivacyValue(
     masking: NormalizedMaskingConfig | null,
     privacy: NormalizedRuntimePrivacyPolicy | null,
     db?: RuntimePrivacyDbContext | null,
+    captureScope?: RequestCaptureScopeState | null,
 ): InlinePrivacyMaterializationResult {
     if (value === undefined) {
         return { value };
@@ -4149,6 +4250,12 @@ function materializeInlinePrivacyValue(
         const valueAfterPrivacy = applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy, db);
         return { value: valueAfterPrivacy };
     } catch {
+        recordRequestCaptureFailure(
+            captureScope ?? getCtx().captureScope,
+            'privacy.inline',
+            target,
+            'privacy_transform_failed',
+        );
         return {
             value: undefined,
             skipped: {
@@ -4169,6 +4276,7 @@ async function materializeInlinePrivacyValueAsync(
     masking: NormalizedMaskingConfig | null,
     privacy: NormalizedRuntimePrivacyPolicy | null,
     db?: RuntimePrivacyDbContext | null,
+    captureScope?: RequestCaptureScopeState | null,
 ): Promise<InlinePrivacyMaterializationResult> {
     if (value === undefined) {
         return { value };
@@ -4181,6 +4289,12 @@ async function materializeInlinePrivacyValueAsync(
         const valueAfterPrivacy = await applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking, privacy, db);
         return { value: valueAfterPrivacy };
     } catch {
+        recordRequestCaptureFailure(
+            captureScope ?? getCtx().captureScope,
+            'privacy.inline',
+            target,
+            'privacy_transform_failed',
+        );
         return {
             value: undefined,
             skipped: {
@@ -4347,6 +4461,7 @@ type FullValueCaptureContext = {
     masking: NormalizedMaskingConfig | null;
     privacy: NormalizedRuntimePrivacyPolicy | null;
     db?: RuntimePrivacyDbContext | null;
+    valueNamespace?: string;
 };
 
 const TRACE_FULL_VALUE_ENTRY_SYMBOL = Symbol('repro.traceFullValueEntries');
@@ -4752,6 +4867,18 @@ function cloneFullValueCandidate(
     const mongoPlaceholder = describeMongoPlaceholder(value);
     if (mongoPlaceholder) return undefined;
 
+    const semanticProjection = projectSemanticInfrastructureValue(value);
+    if (semanticProjection) {
+        return cloneFullValueCandidate(
+            semanticProjection.value,
+            ctx,
+            limits,
+            depth,
+            seen,
+            valuePath,
+        );
+    }
+
     if (isThenable(value)) return undefined;
     if (shouldSkipFullValueObject(value)) return undefined;
 
@@ -4979,6 +5106,18 @@ async function cloneFullValueCandidateAsync(
     const mongoPlaceholder = describeMongoPlaceholder(value);
     if (mongoPlaceholder) return undefined;
 
+    const semanticProjection = projectSemanticInfrastructureValue(value);
+    if (semanticProjection) {
+        return cloneFullValueCandidateAsync(
+            semanticProjection.value,
+            ctx,
+            limits,
+            depth,
+            seen,
+            valuePath,
+        );
+    }
+
     if (isThenable(value)) return undefined;
     if (shouldSkipFullValueObject(value)) return undefined;
 
@@ -5125,12 +5264,18 @@ function getEventTraceValueEntries(event: TraceEventRecord | PendingTraceEventRe
     return undefined;
 }
 
-function collectBatchTraceValueEntries(batch: TraceEventRecord[], batchIndex: number): TraceValueBatchEntry[] {
+function collectBatchTraceValueEntries(
+    batch: TraceEventRecord[],
+    batchIndex: number,
+    emittedValueIds: Set<string> = new Set(),
+): TraceValueBatchEntry[] {
     const collected: TraceValueBatchEntry[] = [];
     batch.forEach((event, eventIndex) => {
         const entries = getEventTraceValueEntries(event);
         if (!Array.isArray(entries) || !entries.length) return;
         entries.forEach((entry) => {
+            if (emittedValueIds.has(entry.id)) return;
+            emittedValueIds.add(entry.id);
             collected.push({
                 ...entry,
                 batchIndex,
@@ -5149,13 +5294,44 @@ function serializedByteLength(value: any): number {
     }
 }
 
+function contentAddressedValueId(
+    target: TraceValueBatchEntry['target'],
+    candidateSerialized: string,
+    capture: FullValueCaptureContext,
+): string {
+    const config = capture.runtimeConfig;
+    const signingKey = String(
+        config.appSecret ||
+        `${config.tenantId || 'tenant'}:${config.appId || 'app'}`,
+    );
+    const namespace = String(
+        capture.valueNamespace ||
+        `${config.tenantId || 'tenant'}:${config.appId || 'app'}`,
+    );
+    const digest = createHmac('sha256', signingKey)
+        .update('repro-captured-value-v1\0')
+        .update(namespace)
+        .update('\0')
+        .update(target)
+        .update('\0')
+        .update(candidateSerialized)
+        .digest('hex')
+        .slice(0, 40);
+    return `rv1_${digest}`;
+}
+
 function estimateTraceBatchSerializedBytes(
     batch: TraceEventRecord[],
     requestRid: string,
     actionId: string | null | undefined,
     batchIndex: number,
+    previouslyEmittedValueIds: ReadonlySet<string> = new Set(),
 ): number {
-    const traceValues = collectBatchTraceValueEntries(batch, batchIndex);
+    const traceValues = collectBatchTraceValueEntries(
+        batch,
+        batchIndex,
+        new Set(previouslyEmittedValueIds),
+    );
     return serializedByteLength({
         actionId: actionId ?? null,
         trace: batch,
@@ -5179,12 +5355,30 @@ function chunkTraceEventsForTransport(
     const boundedEvents = boundTraceEventsForTransport(events);
     const countBatches = chunkArray(boundedEvents, TRACE_BATCH_SIZE);
     const sizedBatches: TraceEventRecord[][] = [];
+    const emittedValueIds = new Set<string>();
     let current: TraceEventRecord[] = [];
 
+    const commitCurrent = (): void => {
+        if (!current.length) return;
+        collectBatchTraceValueEntries(
+            current,
+            sizedBatches.length,
+            emittedValueIds,
+        );
+        sizedBatches.push(current);
+        current = [];
+    };
+
     for (const event of countBatches.flat()) {
         if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
             break;
         }
+        if (current.length >= TRACE_BATCH_SIZE) {
+            commitCurrent();
+            if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
+                break;
+            }
+        }
         const candidate = current.concat(event);
         const batchIndex = sizedBatches.length;
         const estimatedBytes = estimateTraceBatchSerializedBytes(
@@ -5192,15 +5386,15 @@ function chunkTraceEventsForTransport(
             requestRid,
             actionId,
             batchIndex,
+            emittedValueIds,
         );
 
         if (
             current.length > 0 &&
             estimatedBytes > TRACE_BATCH_MAX_SERIALIZED_BYTES
         ) {
-            sizedBatches.push(current);
+            commitCurrent();
             if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
-                current = [];
                 break;
             }
             current = [event];
@@ -5214,7 +5408,7 @@ function chunkTraceEventsForTransport(
         current.length > 0 &&
         sizedBatches.length < TRACE_MAX_BATCHES_PER_REQUEST
     ) {
-        sizedBatches.push(current);
+        commitCurrent();
     }
 
     return sizedBatches;
@@ -5286,7 +5480,11 @@ function createCapturedValueEntry(
         return undefined;
     }
 
-    const valueId = randomUUID();
+    const valueId = contentAddressedValueId(
+        params.target,
+        candidateSerialized,
+        params.capture,
+    );
     const projectedKind =
         candidate && typeof candidate === 'object'
             ? ((candidate as Record<string, any>).__kind || (candidate as Record<string, any>).__type)
@@ -5368,7 +5566,11 @@ async function createCapturedValueEntryAsync(
         return undefined;
     }
 
-    const valueId = randomUUID();
+    const valueId = contentAddressedValueId(
+        params.target,
+        candidateSerialized,
+        params.capture,
+    );
     const projectedKind =
         candidate && typeof candidate === 'object'
             ? ((candidate as Record<string, any>).__kind || (candidate as Record<string, any>).__type)
@@ -5391,6 +5593,18 @@ async function createCapturedValueEntryAsync(
     };
 }
 
+function appendCapturedValueDefinition(
+    sink: TraceValueBatchEntry[],
+    entry: TraceValueBatchEntry | undefined,
+    captureScope?: RequestCaptureScopeState | null,
+): void {
+    if (!entry) return;
+    const emitted = captureScope?.emittedValueDefinitionIds;
+    if (emitted?.has(entry.id)) return;
+    emitted?.add(entry.id);
+    sink.push(entry);
+}
+
 function maybeCaptureRequestValue(
     params: {
         target: 'request.headers' | 'request.body' | 'request.params' | 'request.query' | 'response.body';
@@ -5402,9 +5616,7 @@ function maybeCaptureRequestValue(
 ): TraceValueCaptureRef | undefined {
     const result = createCapturedValueEntry(params);
     if (!result) return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry);
     return result.captureRef;
 }
 
@@ -5416,12 +5628,22 @@ async function maybeCaptureRequestValueAsync(
         capture: FullValueCaptureContext;
     },
     sink: TraceValueBatchEntry[],
+    captureScope?: RequestCaptureScopeState | null,
 ): Promise<TraceValueCaptureRef | undefined> {
-    const result = await createCapturedValueEntryAsync(params);
-    if (!result) return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
+    let result: Awaited<ReturnType<typeof createCapturedValueEntryAsync>>;
+    try {
+        result = await createCapturedValueEntryAsync(params);
+    } catch {
+        recordRequestCaptureFailure(
+            captureScope ?? getCtx().captureScope,
+            'privacy.full_value',
+            params.target,
+            'privacy_transform_failed',
+        );
+        return { status: 'failed-policy' };
     }
+    if (!result) return undefined;
+    appendCapturedValueDefinition(sink, result.entry, captureScope);
     return result.captureRef;
 }
 
@@ -5445,8 +5667,19 @@ async function maybeCaptureTraceValueAsync(
         capture: FullValueCaptureContext;
         metadata?: Partial<TraceValueBatchEntry>;
     },
+    captureScope?: RequestCaptureScopeState | null,
 ): Promise<{ captureRef: TraceValueCaptureRef; entry?: TraceValueBatchEntry } | undefined> {
-    return await createCapturedValueEntryAsync(params);
+    try {
+        return await createCapturedValueEntryAsync(params);
+    } catch {
+        recordRequestCaptureFailure(
+            captureScope ?? getCtx().captureScope,
+            'privacy.full_value',
+            params.target,
+            'privacy_transform_failed',
+        );
+        return { captureRef: { status: 'failed-policy' } };
+    }
 }
 
 function maybeCaptureDbValue(
@@ -5460,9 +5693,7 @@ function maybeCaptureDbValue(
 ): TraceValueCaptureRef | undefined {
     const result = createCapturedValueEntry(params);
     if (!result) return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
-    }
+    appendCapturedValueDefinition(sink, result.entry);
     return result.captureRef;
 }
 
@@ -5474,12 +5705,22 @@ async function maybeCaptureDbValueAsync(
         capture: FullValueCaptureContext;
     },
     sink: TraceValueBatchEntry[],
+    captureScope?: RequestCaptureScopeState | null,
 ): Promise<TraceValueCaptureRef | undefined> {
-    const result = await createCapturedValueEntryAsync(params);
-    if (!result) return undefined;
-    if (result.entry) {
-        sink.push(result.entry);
+    let result: Awaited<ReturnType<typeof createCapturedValueEntryAsync>>;
+    try {
+        result = await createCapturedValueEntryAsync(params);
+    } catch {
+        recordRequestCaptureFailure(
+            captureScope ?? getCtx().captureScope,
+            'privacy.full_value',
+            params.target,
+            'privacy_transform_failed',
+        );
+        return { status: 'failed-policy' };
     }
+    if (!result) return undefined;
+    appendCapturedValueDefinition(sink, result.entry, captureScope);
     return result.captureRef;
 }
 
@@ -5511,18 +5752,30 @@ async function maybeCaptureDbValueFromCandidatesAsync(
         capture: FullValueCaptureContext;
     },
     sink: TraceValueBatchEntry[],
+    captureScope?: RequestCaptureScopeState | null,
 ): Promise<TraceValueCaptureRef | undefined> {
     let skippedRef: TraceValueCaptureRef | undefined;
     for (const rawValue of params.rawValues) {
-        const result = await createCapturedValueEntryAsync({
-            target: params.target,
-            rawValue,
-            previewValue: params.previewValue,
-            capture: params.capture,
-        });
+        let result: Awaited<ReturnType<typeof createCapturedValueEntryAsync>>;
+        try {
+            result = await createCapturedValueEntryAsync({
+                target: params.target,
+                rawValue,
+                previewValue: params.previewValue,
+                capture: params.capture,
+            });
+        } catch {
+            recordRequestCaptureFailure(
+                captureScope ?? getCtx().captureScope,
+                'privacy.full_value',
+                params.target,
+                'privacy_transform_failed',
+            );
+            return { status: 'failed-policy' };
+        }
         if (!result) continue;
         if (result.entry) {
-            sink.push(result.entry);
+            appendCapturedValueDefinition(sink, result.entry, captureScope);
             return result.captureRef;
         }
         if (!skippedRef) {
@@ -5827,7 +6080,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
 
         const clockSkewMs = headerTs !== null ? headerTs - requestStartRaw : 0;
         const rid = nextRequestId(requestEpochMs);
-        const captureScope = createRequestCaptureScope(rid, 'http');
+        const captureScope = createRequestCaptureScope(rid, 'http', captureCfg);
         emitRequestCaptureStart(captureCfg, sid, aid, captureScope, requestEpochMs);
         const t0 = requestStartRaw;
         const url = (req as any).originalUrl || req.url || '/';
@@ -6029,9 +6282,11 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         endpointTraceCtx,
                         masking,
                         activePrivacy,
+                        undefined,
+                        captureScope,
                     );
                 const requestBody = requestBodyMaterialization.value;
-                const requestParams = await applyPrivacyThenMaskAsync(
+                const requestParamsMaterialization = await materializeInlinePrivacyValueAsync(
                     'request.params',
                     sanitizeRequestSnapshot((req as any).params),
                     captureCfg,
@@ -6039,8 +6294,11 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                     endpointTraceCtx,
                     masking,
                     activePrivacy,
+                    undefined,
+                    captureScope,
                 );
-                const requestQuery = await applyPrivacyThenMaskAsync(
+                const requestParams = requestParamsMaterialization.value;
+                const requestQueryMaterialization = await materializeInlinePrivacyValueAsync(
                     'request.query',
                     sanitizeRequestSnapshot((req as any).query),
                     captureCfg,
@@ -6048,8 +6306,11 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                     endpointTraceCtx,
                     masking,
                     activePrivacy,
+                    undefined,
+                    captureScope,
                 );
-                const maskedHeaders = await applyPrivacyThenMaskAsync(
+                const requestQuery = requestQueryMaterialization.value;
+                const requestHeadersMaterialization = await materializeInlinePrivacyValueAsync(
                     'request.headers',
                     requestHeaders,
                     captureCfg,
@@ -6057,7 +6318,10 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                     endpointTraceCtx,
                     masking,
                     activePrivacy,
+                    undefined,
+                    captureScope,
                 );
+                const maskedHeaders = requestHeadersMaterialization.value;
                 const responseBodyMaterialization = capturedBody === undefined
                     ? { value: undefined }
                     : limitRawInlinePrivacyValue('response.body', capturedBody)
@@ -6069,6 +6333,8 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                             endpointTraceCtx,
                             masking,
                             activePrivacy,
+                            undefined,
+                            captureScope,
                         );
                 const responseBody = responseBodyMaterialization.value;
                 const requestValueEntries: TraceValueBatchEntry[] = [];
@@ -6085,8 +6351,9 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                             trace: endpointTraceCtx,
                             masking,
                             privacy: activePrivacy,
+                            valueNamespace: sid,
                         },
-                    }, requestValueEntries);
+                    }, requestValueEntries, captureScope);
                 const paramsValueCapture = await maybeCaptureRequestValueAsync({
                     target: 'request.params',
                     rawValue: (req as any).params,
@@ -6098,8 +6365,9 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
-                }, requestValueEntries);
+                }, requestValueEntries, captureScope);
                 const queryValueCapture = await maybeCaptureRequestValueAsync({
                     target: 'request.query',
                     rawValue: (req as any).query,
@@ -6111,8 +6379,9 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
-                }, requestValueEntries);
+                }, requestValueEntries, captureScope);
                 const headersValueCapture = await maybeCaptureRequestValueAsync({
                     target: 'request.headers',
                     rawValue: req.headers,
@@ -6124,8 +6393,9 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         trace: endpointTraceCtx,
                         masking,
                         privacy: activePrivacy,
+                        valueNamespace: sid,
                     },
-                }, requestValueEntries);
+                }, requestValueEntries, captureScope);
                 const respBodyValueCapture = capturedBody === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
@@ -6139,15 +6409,16 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                             trace: endpointTraceCtx,
                             masking,
                             privacy: activePrivacy,
+                            valueNamespace: sid,
                         },
-                    }, requestValueEntries);
+                    }, requestValueEntries, captureScope);
 
                 const responseDurationMs =
                     finishedAt !== null && Number.isFinite(finishedAt)
                         ? Math.max(0, finishedAt - t0)
                         : Date.now() - t0;
                 const requestPayload: Record<string, any> = {
-                    rid,
+            rid,
                     method: req.method,
                     url,
                     path,
@@ -6201,9 +6472,43 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                             t: requestEpochMs,
                         }]
                     });
-                    captureScope.backendRequestCount += 1;
                 } catch {
-                    // never break user code
+                    recordRequestCaptureFailure(
+                        captureScope,
+                        'request.capture',
+                        'backend_request',
+                        'request_materialization_failed',
+                    );
+                    // Preserve non-sensitive request metadata so the manifest cannot
+                    // silently turn a failed policy capture into a zero-request scope.
+                    post(captureCfg, sid, {
+                        entries: [{
+                            actionId: aid,
+                            request: {
+                                rid,
+                                method: req.method,
+                                url,
+                                path,
+                                status: res.statusCode,
+                                durMs:
+                                    finishedAt !== null && Number.isFinite(finishedAt)
+                                        ? Math.max(0, finishedAt - t0)
+                                        : Date.now() - t0,
+                                key,
+                                bodyMaterialization: {
+                                    status: 'skipped',
+                                    reason: 'request_materialization_failed',
+                                    target: 'request.body',
+                                },
+                                respBodyMaterialization: {
+                                    status: 'skipped',
+                                    reason: 'request_materialization_failed',
+                                    target: 'response.body',
+                                },
+                            },
+                            t: requestEpochMs,
+                        }],
+                    });
                 }
             };
 
@@ -6326,6 +6631,8 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                                 maskReq,
                                 masking,
                                 resolvePrivacy,
+                                captureScope,
+                                valueNamespace: sid,
                             });
                             const baseEvents = balanceTraceEvents(materializedEvents.slice());
                             const orderedEvents = TRACE_ORDER_MODE === 'tree'
@@ -6344,16 +6651,30 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                             }
 
                         } catch {
+                            recordRequestCaptureFailure(
+                                captureScope,
+                                'trace.capture',
+                                'trace.batches',
+                                'trace_capture_failed',
+                            );
                             captureScope.traceBatchCount = 0;
                             traceBatches = [];
-                        } finally {
-                            emitRequestCaptureManifest(traceBatches.length);
                         }
 
+                        // Finalize policy/materialization status before publishing the
+                        // high-priority manifest. The manifest must lead its evidence
+                        // on the wire so a large trace queue cannot starve completion.
+                        emitRequestCaptureManifest(traceBatches.length);
+
                         try {
+                            const emittedValueIds = new Set<string>();
                             for (let i = 0; i < traceBatches.length; i++) {
                                 const batch = traceBatches[i];
-                                const traceValues = collectBatchTraceValueEntries(batch, i);
+                                const traceValues = collectBatchTraceValueEntries(
+                                    batch,
+                                    i,
+                                    emittedValueIds,
+                                );
 
                                 post(captureCfg, sid, {
                                     entries: [{
@@ -6370,7 +6691,12 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                                 });
                             }
                         } catch {
-                            // never break user code
+                            recordRequestCaptureFailure(
+                                captureScope,
+                                'trace.enqueue',
+                                'trace.batches',
+                                'trace_enqueue_failed',
+                            );
                         }
                     };
                 }
@@ -6958,12 +7284,6 @@ function dehydrateComplexValue(value: any) {
         }
     } catch {}
 
-    const ctor = (value as any)?.constructor?.name;
-    if (ctor && ctor !== 'Object') {
-        const plain = safeJson(value);
-        if (plain !== undefined) return plain;
-    }
-
     return value;
 }
 
@@ -6971,6 +7291,11 @@ function emitDbQuery(cfg: any, sid?: string, aid?: string, payload?: any) {
     const ctx = getCtx() as Ctx;
     const spanContext = payload?.spanContext ?? captureSpanContextFromTracer();
     if (!shouldCaptureDbSpan(spanContext)) return;
+    if (sid && ctx.captureScope) {
+        // Count the observed database operation before asynchronous privacy
+        // materialization. A later failure must remain visible to completeness.
+        ctx.captureScope.dbChangeCount += 1;
+    }
     const runCtx: Ctx = {
         sid: ctx.sid,
         aid: ctx.aid,
@@ -6982,7 +7307,14 @@ function emitDbQuery(cfg: any, sid?: string, aid?: string, payload?: any) {
     };
     scheduleSdkBackgroundWork(async () => {
         await als.run(runCtx, async () => {
-            await emitDbQueryAsync(cfg, sid, aid, payload).catch(() => undefined);
+            await emitDbQueryAsync(cfg, sid, aid, payload).catch(() => {
+                recordRequestCaptureFailure(
+                    runCtx.captureScope,
+                    'db.capture',
+                    'db.change',
+                    'db_capture_failed',
+                );
+            });
         });
     }, { priority: 'high' });
 }
@@ -7026,6 +7358,7 @@ async function emitDbQueryAsync(cfg: any, sid?: string, aid?: string, payload?:
         masking: null,
         privacy,
         db: dbContext,
+        valueNamespace: sid,
     };
     const dbValues: TraceValueBatchEntry[] = [];
     const pkValueCapture = pkMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
@@ -7033,37 +7366,37 @@ async function emitDbQueryAsync(cfg: any, sid?: string, aid?: string, payload?:
         rawValue: payload.pk,
         previewValue: pkPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const beforeValueCapture = beforeMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.before',
         rawValue: payload.before,
         previewValue: beforePreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const afterValueCapture = afterMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.after',
         rawValue: payload.after,
         previewValue: afterPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const queryValueCapture = queryMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.query',
         rawValue: querySource,
         previewValue: queryPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const resultMetaValueCapture = resultMetaMaterialization.skipped ? undefined : await maybeCaptureDbValueFromCandidatesAsync({
         target: 'db.resultMeta',
         rawValues: buildResultMetaFullValueCandidates(payload.resultMetaRaw, resultMetaSource),
         previewValue: resultMetaPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const errorValueCapture = errorMaterialization.skipped ? undefined : await maybeCaptureDbValueAsync({
         target: 'db.error',
         rawValue: payload.error,
         previewValue: errorPreview,
         capture,
-    }, dbValues);
+    }, dbValues, ctx.captureScope);
     const dbEntry = attachSpanContext({
         type: payload.type ?? 'mongo',
         collection: payload.collection,
@@ -7097,8 +7430,13 @@ async function emitDbQueryAsync(cfg: any, sid?: string, aid?: string, payload?:
             t: payload.t,
         }]
     });
-    if (enqueued && ctx.captureScope) {
-        ctx.captureScope.dbChangeCount += 1;
+    if (!enqueued) {
+        recordRequestCaptureFailure(
+            ctx.captureScope,
+            'db.enqueue',
+            'db.change',
+            'db_enqueue_failed',
+        );
     }
 }
 
@@ -7534,6 +7872,7 @@ async function materializeKafkaRequestBody(
     cfg: ReproMiddlewareConfig,
     maskReq: MaskRequestContext,
     body: Record<string, any>,
+    captureScope?: RequestCaptureScopeState | null,
 ): Promise<InlinePrivacyMaterializationResult> {
     return materializeInlinePrivacyValueAsync(
         'request.body',
@@ -7543,6 +7882,8 @@ async function materializeKafkaRequestBody(
         null,
         normalizeMaskingConfig(cfg.masking),
         getRuntimePrivacyState(cfg).policy ?? null,
+        undefined,
+        captureScope,
     );
 }
 
@@ -7660,6 +8001,7 @@ function recordKafkaTraceEvent(
         trace: candidate,
         masking,
         privacy,
+        valueNamespace: getCtx().sid,
     };
     const traceValueMetadata = {
         fn: evt.fn,
@@ -7828,6 +8170,7 @@ async function recordKafkaTraceEventAsync(
         maskReq,
         masking,
         resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
+        valueNamespace: getCtx().sid,
     });
     sink.push(...materializedEvents);
 }
@@ -7848,10 +8191,11 @@ function buildKafkaTraceEntries(
         requestRid,
         actionId,
     );
+    const emittedValueIds = new Set<string>();
     return batches.map((batch, index) => ({
         actionId: actionId ?? null,
         trace: batch,
-        traceValues: collectBatchTraceValueEntries(batch, index),
+        traceValues: collectBatchTraceValueEntries(batch, index, emittedValueIds),
         traceBatch: {
             rid: requestRid,
             index,
@@ -7882,22 +8226,32 @@ function scheduleKafkaTraceFlush(
                 const evt = buildPendingKafkaTraceEvent(rawTraceEvent);
                 if (evt) pendingEvents.push(evt);
             }
-            if (!pendingEvents.length) return;
-            const masking = normalizeMaskingConfig(cfg.masking);
-            const preparedEvents = preparePendingTraceEventsForFlush(pendingEvents);
-            const materializedEvents = await materializePendingTraceEventsAsync(preparedEvents, {
-                cfg,
-                maskReq,
-                masking,
-                resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
-            });
-            const entries = buildKafkaTraceEntries(actionId, requestRid, materializedEvents);
+            let entries: LegacyEntry[] = [];
+            try {
+                if (pendingEvents.length) {
+                    const masking = normalizeMaskingConfig(cfg.masking);
+                    const preparedEvents = preparePendingTraceEventsForFlush(pendingEvents);
+                    const materializedEvents = await materializePendingTraceEventsAsync(preparedEvents, {
+                        cfg,
+                        maskReq,
+                        masking,
+                        resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
+                        captureScope,
+                        valueNamespace: sid,
+                    });
+                    entries = buildKafkaTraceEntries(actionId, requestRid, materializedEvents);
+                }
+            } catch {
+                recordRequestCaptureFailure(
+                    captureScope,
+                    'trace.capture',
+                    'trace.batches',
+                    'trace_capture_failed',
+                );
+            }
             if (captureScope) {
                 captureScope.traceBatchCount = entries.length;
             }
-            if (entries.length) {
-                post(cfg, sid, { entries });
-            }
             if (captureScope) {
                 post(cfg, sid, {
                     entries: [{
@@ -7909,7 +8263,10 @@ function scheduleKafkaTraceFlush(
                         ),
                         t: alignedNow(),
                     }],
-                });
+                }, { priority: 'high' });
+            }
+            if (entries.length) {
+                post(cfg, sid, { entries });
             }
         });
     }, { priority: 'high' });
@@ -7928,7 +8285,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
             const aid = ctx.aid ?? fallback.aid ?? null;
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
-            const captureScope = createRequestCaptureScope(publishRid, 'kafka');
+            const captureScope = createRequestCaptureScope(publishRid, 'kafka', cfg);
             emitRequestCaptureStart(cfg, sid, aid, captureScope);
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
             const topic = sanitizeKafkaTopic((payloadObj as any).topic);
@@ -7987,7 +8344,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                     traceId: span?.traceId ?? null,
                     spanId: span?.spanId ?? null,
                     parentSpanId: span?.parentSpanId ?? null,
-                });
+                }, captureScope);
 
                 const requestPayload: Record<string, any> = {
                     rid: publishRid,
@@ -8018,7 +8375,6 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                         },
                     ],
                 });
-                captureScope.backendRequestCount += 1;
                 post(cfg, sid, {
                     entries: [{
                         actionId: aid ?? null,
@@ -8043,7 +8399,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
             const aid = ctx.aid ?? fallback.aid ?? null;
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
-            const captureScope = createRequestCaptureScope(publishRid, 'kafka');
+            const captureScope = createRequestCaptureScope(publishRid, 'kafka', cfg);
             emitRequestCaptureStart(cfg, sid, aid, captureScope);
 
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
@@ -8137,7 +8493,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                     traceId: span?.traceId ?? null,
                     spanId: span?.spanId ?? null,
                     parentSpanId: span?.parentSpanId ?? null,
-                });
+                }, captureScope);
                 const requestPayload: Record<string, any> = {
                     rid: publishRid,
                     method: 'KAFKA_PUBLISH_BATCH',
@@ -8167,7 +8523,6 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                         },
                     ],
                 });
-                captureScope.backendRequestCount += 1;
                 post(cfg, sid, {
                     entries: [{
                         actionId: aid ?? null,
@@ -8194,7 +8549,7 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
         const aid = runtime.aid;
         const consumeRid = nextRequestId(`${topic}-${message?.offset ?? alignedNow()}`);
         const traceId = consumeRid;
-        const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
+        const captureScope = createRequestCaptureScope(consumeRid, 'kafka', cfg);
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
@@ -8266,7 +8621,7 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
                 valueEncoding: messagePayload.valueEncoding,
                 valueBytes: messagePayload.valueBytes,
                 message: messagePayload,
-            });
+            }, captureScope);
             const requestPayload: Record<string, any> = {
                 rid: consumeRid,
                 method: 'KAFKA_CONSUME',
@@ -8288,7 +8643,6 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
                     t: alignedNow(),
                 }],
             });
-            captureScope.backendRequestCount += 1;
             scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
         }
     };
@@ -8305,7 +8659,7 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
         const aid = runtime.aid;
         const consumeRid = nextRequestId(`${topic}-batch-${alignedNow()}`);
         const traceId = consumeRid;
-        const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
+        const captureScope = createRequestCaptureScope(consumeRid, 'kafka', cfg);
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
@@ -8375,7 +8729,7 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
                 parentSpanId: runtime.parentSpanId,
                 firstMessageKey: firstMessagePayload?.key ?? null,
                 messages: messages.map((message: any) => buildKafkaMessagePayload(message)),
-            });
+            }, captureScope);
             const requestPayload: Record<string, any> = {
                 rid: consumeRid,
                 method: 'KAFKA_CONSUME_BATCH',
@@ -8397,7 +8751,6 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
                     t: alignedNow(),
                 }],
             });
-            captureScope.backendRequestCount += 1;
             scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
         }
     };
@@ -8820,24 +9173,28 @@ function scheduleAmqpTraceFlush(
             }
 
             let entries: LegacyEntry[] = [];
-            if (pendingEvents.length) {
-                const masking = normalizeMaskingConfig(cfg.masking);
-                const preparedEvents = preparePendingTraceEventsForFlush(pendingEvents);
-                const materializedEvents = await materializePendingTraceEventsAsync(preparedEvents, {
-                    cfg,
-                    maskReq,
-                    masking,
-                    resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
-                });
-                entries = buildAmqpTraceEntries(actionId, requestRid, materializedEvents);
-                captureScope.traceBatchCount = entries.length;
-                if (entries.length) {
-                    post(cfg, sid, { entries });
+            try {
+                if (pendingEvents.length) {
+                    const masking = normalizeMaskingConfig(cfg.masking);
+                    const preparedEvents = preparePendingTraceEventsForFlush(pendingEvents);
+                    const materializedEvents = await materializePendingTraceEventsAsync(preparedEvents, {
+                        cfg,
+                        maskReq,
+                        masking,
+                        resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
+                        captureScope,
+                    });
+                    entries = buildAmqpTraceEntries(actionId, requestRid, materializedEvents);
                 }
-            } else {
-                captureScope.traceBatchCount = 0;
+            } catch {
+                recordRequestCaptureFailure(
+                    captureScope,
+                    'trace.capture',
+                    'trace.batches',
+                    'trace_capture_failed',
+                );
             }
-
+            captureScope.traceBatchCount = entries.length;
             post(cfg, sid, {
                 entries: [{
                     actionId: actionId ?? null,
@@ -8848,7 +9205,10 @@ function scheduleAmqpTraceFlush(
                     ),
                     t: alignedNow(),
                 }],
-            });
+            }, { priority: 'high' });
+            if (entries.length) {
+                post(cfg, sid, { entries });
+            }
         });
     }, { priority: 'high' });
 }
@@ -8920,7 +9280,12 @@ function scheduleAmqpPublishCapture(params: {
     };
 
     scheduleSdkBackgroundWork(async () => {
-        const bodyMaterialization = await materializeKafkaRequestBody(params.cfg, maskReq, body);
+        const bodyMaterialization = await materializeKafkaRequestBody(
+            params.cfg,
+            maskReq,
+            body,
+            params.captureScope,
+        );
         const requestPayload: Record<string, any> = {
             rid: params.publishRid,
             method: params.method,
@@ -8951,7 +9316,6 @@ function scheduleAmqpPublishCapture(params: {
                 t: alignedNow(),
             }],
         });
-        params.captureScope.backendRequestCount += 1;
         post(params.cfg, params.sid!, {
             entries: [{
                 actionId: params.aid ?? null,
@@ -9013,7 +9377,7 @@ function patchAmqplibPublishMethod(
             : `amqp://queue/${queue}`;
         const key = `${method} ${methodName === 'publish' ? `${exchange || 'default'}/${routingKey}` : queue}`;
         const content = methodName === 'publish' ? args[2] : args[1];
-        const captureScope = createRequestCaptureScope(publishRid, 'amqp');
+        const captureScope = createRequestCaptureScope(publishRid, 'amqp', cfg);
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const t0 = Date.now();
         let finished = false;
@@ -9103,7 +9467,7 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
         const deliveryTag = message?.fields?.deliveryTag ?? alignedNow();
         const consumeRid = nextRequestId(`${queueName}-${deliveryTag}`);
         const traceId = consumeRid;
-        const captureScope = createRequestCaptureScope(consumeRid, 'amqp');
+        const captureScope = createRequestCaptureScope(consumeRid, 'amqp', cfg);
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
@@ -9188,7 +9552,12 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
             };
 
             scheduleSdkBackgroundWork(async () => {
-                const bodyMaterialization = await materializeKafkaRequestBody(cfg, maskReq, body);
+                const bodyMaterialization = await materializeKafkaRequestBody(
+                    cfg,
+                    maskReq,
+                    body,
+                    captureScope,
+                );
                 const requestPayload: Record<string, any> = {
                     rid: consumeRid,
                     method: 'AMQP_CONSUME',
@@ -9210,7 +9579,6 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
                         t: alignedNow(),
                     }],
                 });
-                captureScope.backendRequestCount += 1;
                 scheduleAmqpTraceFlush(cfg, amqpCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
             }, { priority: 'high' });
         };
@@ -11526,5 +11894,6 @@ export const __reproTestHooks = {
     estimateTraceBatchSerializedBytesForTest: estimateTraceBatchSerializedBytes,
     sanitizeTraceValueForPrivacyForTest: sanitizeTraceValueForPrivacy,
     sanitizeMaterializedTraceValueForTest: sanitizeMaterializedTraceValue,
+    projectSemanticInfrastructureValueForTest: projectSemanticInfrastructureValue,
     getEventTraceValueEntriesForTest: getEventTraceValueEntries,
 };