@reproapp/node-sdk 0.0.46 → 0.0.47

package/dist/index.js

@@ -817,16 +817,45 @@ function attachSpanContext(target, span) {
     }
     return target;
 }
-function createRequestCaptureScope(requestRid, transport) {
+function createRequestCaptureScope(requestRid, transport, cfg) {
+    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,
     };
 }
+function recordRequestCaptureFailure(scope, stage, target, reason) {
+    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(scope, traceBatchTotal, closedAtMs) {
     const expectedTraceBatches = Math.max(0, Math.trunc(traceBatchTotal));
     const closedAt = typeof closedAtMs === 'number' && Number.isFinite(closedAtMs)
@@ -848,6 +877,19 @@ function buildRequestCaptureManifestPayload(scope, traceBatchTotal, closedAtMs)
                 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,
     };
 }
@@ -1024,12 +1066,6 @@ const SDK_BACKGROUND_MAX_DEFER_MS = (() => {
         return Math.trunc(env);
     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)
@@ -1378,28 +1414,9 @@ function scheduleSdkBackgroundDrain(delayMs = 0) {
     catch { }
 }
 async function runSdkBackgroundWork(work) {
-    if (!Number.isFinite(SDK_BACKGROUND_WORK_TIMEOUT_MS) || SDK_BACKGROUND_WORK_TIMEOUT_MS <= 0) {
-        await work();
-        return;
-    }
-    let timeout = null;
-    const workPromise = Promise.resolve()
+    await Promise.resolve()
         .then(work)
         .catch(() => undefined);
-    const timeoutPromise = new Promise((resolve) => {
-        timeout = setTimeout(resolve, SDK_BACKGROUND_WORK_TIMEOUT_MS);
-        try {
-            timeout.unref?.();
-        }
-        catch { }
-    });
-    await Promise.race([workPromise, timeoutPromise]);
-    if (timeout) {
-        try {
-            clearTimeout(timeout);
-        }
-        catch { }
-    }
 }
 async function drainQueuedIngestBeforeBackgroundWork() {
     (0, client_1.kickIngestQueueDrain)();
@@ -2258,7 +2275,7 @@ 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;
+    return Math.ceil(TRACE_MAX_EVENTS_PER_REQUEST / TRACE_BATCH_SIZE);
 })();
 const TRACE_FLUSH_DELAY_MS = 20;
 // Choose how to order trace events in payloads.
@@ -2828,7 +2845,7 @@ async function materializePendingTraceEvents(events, params) {
                     previewValue: evt.args,
                     capture: captureContext,
                     metadata: traceValueMetadata,
-                });
+                }, params.captureScope);
                 if (argsValueCapture?.entry) {
                     attachTraceValueEntry(evt, argsValueCapture.entry);
                 }
@@ -2850,7 +2867,7 @@ async function materializePendingTraceEvents(events, params) {
                     previewValue: evt.returnValue,
                     capture: captureContext,
                     metadata: traceValueMetadata,
-                });
+                }, params.captureScope);
                 if (returnValueCapture?.entry) {
                     attachTraceValueEntry(evt, returnValueCapture.entry);
                 }
@@ -2872,7 +2889,7 @@ async function materializePendingTraceEvents(events, params) {
                     previewValue: evt.error,
                     capture: captureContext,
                     metadata: traceValueMetadata,
-                });
+                }, params.captureScope);
                 if (errorValueCapture?.entry) {
                     attachTraceValueEntry(evt, errorValueCapture.entry);
                 }
@@ -2886,8 +2903,21 @@ async function materializePendingTraceEvents(events, params) {
 }
 function stripPendingTraceValues(events, reason) {
     for (const evt of events) {
-        if (!evt.__reproPending)
+        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;
@@ -2908,6 +2938,7 @@ async function materializePendingTraceEventsAsync(events, params) {
             });
         }
         catch {
+            recordRequestCaptureFailure(params.captureScope ?? getCtx().captureScope, 'privacy.trace', 'trace.values', 'main_thread_materialization_failed');
             return stripPendingTraceValues(events, 'main_thread_failed');
         }
     }
@@ -2927,9 +2958,6 @@ async function materializePendingTraceEventsAsync(events, params) {
         });
     }
     catch (err) {
-        if (isTraceMaterializerTimeoutError(err)) {
-            return stripPendingTraceValues(events, 'worker_timeout');
-        }
         try {
             return await materializePendingTraceEvents(events, {
                 ...params,
@@ -2937,7 +2965,10 @@ async function materializePendingTraceEventsAsync(events, params) {
             });
         }
         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');
         }
     }
 }
@@ -3404,7 +3435,7 @@ function limitRawInlinePrivacyValue(target, value) {
     const limited = limitInlinePrivacyValue(target, value);
     return limited.skipped ? limited : null;
 }
-function materializeInlinePrivacyValue(target, value, cfg, req, trace, masking, privacy, db) {
+function materializeInlinePrivacyValue(target, value, cfg, req, trace, masking, privacy, db, captureScope) {
     if (value === undefined) {
         return { value };
     }
@@ -3416,6 +3447,7 @@ function materializeInlinePrivacyValue(target, value, cfg, req, trace, masking,
         return { value: valueAfterPrivacy };
     }
     catch {
+        recordRequestCaptureFailure(captureScope ?? getCtx().captureScope, 'privacy.inline', target, 'privacy_transform_failed');
         return {
             value: undefined,
             skipped: {
@@ -3426,7 +3458,7 @@ function materializeInlinePrivacyValue(target, value, cfg, req, trace, masking,
         };
     }
 }
-async function materializeInlinePrivacyValueAsync(target, value, cfg, req, trace, masking, privacy, db) {
+async function materializeInlinePrivacyValueAsync(target, value, cfg, req, trace, masking, privacy, db, captureScope) {
     if (value === undefined) {
         return { value };
     }
@@ -3438,6 +3470,7 @@ async function materializeInlinePrivacyValueAsync(target, value, cfg, req, trace
         return { value: valueAfterPrivacy };
     }
     catch {
+        recordRequestCaptureFailure(captureScope ?? getCtx().captureScope, 'privacy.inline', target, 'privacy_transform_failed');
         return {
             value: undefined,
             skipped: {
@@ -4330,6 +4363,13 @@ function chunkTraceEventsForTransport(events, requestRid, actionId) {
         if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
             break;
         }
+        if (current.length >= TRACE_BATCH_SIZE) {
+            sizedBatches.push(current);
+            current = [];
+            if (sizedBatches.length >= TRACE_MAX_BATCHES_PER_REQUEST) {
+                break;
+            }
+        }
         const candidate = current.concat(event);
         const batchIndex = sizedBatches.length;
         const estimatedBytes = estimateTraceBatchSerializedBytes(candidate, requestRid, actionId, batchIndex);
@@ -4461,8 +4501,15 @@ function maybeCaptureRequestValue(params, sink) {
     }
     return result.captureRef;
 }
-async function maybeCaptureRequestValueAsync(params, sink) {
-    const result = await createCapturedValueEntryAsync(params);
+async function maybeCaptureRequestValueAsync(params, sink, captureScope) {
+    let result;
+    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;
     if (result.entry) {
@@ -4473,8 +4520,14 @@ async function maybeCaptureRequestValueAsync(params, sink) {
 function maybeCaptureTraceValue(params) {
     return createCapturedValueEntry(params);
 }
-async function maybeCaptureTraceValueAsync(params) {
-    return await createCapturedValueEntryAsync(params);
+async function maybeCaptureTraceValueAsync(params, captureScope) {
+    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(params, sink) {
     const result = createCapturedValueEntry(params);
@@ -4485,8 +4538,15 @@ function maybeCaptureDbValue(params, sink) {
     }
     return result.captureRef;
 }
-async function maybeCaptureDbValueAsync(params, sink) {
-    const result = await createCapturedValueEntryAsync(params);
+async function maybeCaptureDbValueAsync(params, sink, captureScope) {
+    let result;
+    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;
     if (result.entry) {
@@ -4512,15 +4572,22 @@ function buildResultMetaFullValueCandidates(resultMetaRaw, resultMetaSource) {
     pushUniqueCaptureCandidate(candidates, resultMetaSource);
     return candidates;
 }
-async function maybeCaptureDbValueFromCandidatesAsync(params, sink) {
+async function maybeCaptureDbValueFromCandidatesAsync(params, sink, captureScope) {
     let skippedRef;
     for (const rawValue of params.rawValues) {
-        const result = await createCapturedValueEntryAsync({
-            target: params.target,
-            rawValue,
-            previewValue: params.previewValue,
-            capture: params.capture,
-        });
+        let result;
+        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) {
@@ -4690,7 +4757,7 @@ function reproMiddleware(cfg) {
         const resolvePrivacy = () => getRuntimePrivacyState(captureCfg).policy ?? null;
         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.originalUrl || req.url || '/';
@@ -4893,15 +4960,18 @@ function reproMiddleware(cfg) {
                 const activePrivacy = resolvePrivacy();
                 const requestBodyRaw = req.body;
                 const requestBodyMaterialization = limitRawInlinePrivacyValue('request.body', requestBodyRaw)
-                    ?? await materializeInlinePrivacyValueAsync('request.body', sanitizeRequestSnapshot(requestBodyRaw), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                    ?? await materializeInlinePrivacyValueAsync('request.body', sanitizeRequestSnapshot(requestBodyRaw), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy, undefined, captureScope);
                 const requestBody = requestBodyMaterialization.value;
-                const requestParams = await applyPrivacyThenMaskAsync('request.params', sanitizeRequestSnapshot(req.params), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
-                const requestQuery = await applyPrivacyThenMaskAsync('request.query', sanitizeRequestSnapshot(req.query), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
-                const maskedHeaders = await applyPrivacyThenMaskAsync('request.headers', requestHeaders, captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                const requestParamsMaterialization = await materializeInlinePrivacyValueAsync('request.params', sanitizeRequestSnapshot(req.params), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy, undefined, captureScope);
+                const requestParams = requestParamsMaterialization.value;
+                const requestQueryMaterialization = await materializeInlinePrivacyValueAsync('request.query', sanitizeRequestSnapshot(req.query), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy, undefined, captureScope);
+                const requestQuery = requestQueryMaterialization.value;
+                const requestHeadersMaterialization = await materializeInlinePrivacyValueAsync('request.headers', requestHeaders, captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy, undefined, captureScope);
+                const maskedHeaders = requestHeadersMaterialization.value;
                 const responseBodyMaterialization = capturedBody === undefined
                     ? { value: undefined }
                     : limitRawInlinePrivacyValue('response.body', capturedBody)
-                        ?? await materializeInlinePrivacyValueAsync('response.body', sanitizeRequestSnapshot(capturedBody), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
+                        ?? await materializeInlinePrivacyValueAsync('response.body', sanitizeRequestSnapshot(capturedBody), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy, undefined, captureScope);
                 const responseBody = responseBodyMaterialization.value;
                 const requestValueEntries = [];
                 const bodyValueCapture = requestBodyRaw === undefined
@@ -4918,7 +4988,7 @@ function reproMiddleware(cfg) {
                             masking,
                             privacy: activePrivacy,
                         },
-                    }, requestValueEntries);
+                    }, requestValueEntries, captureScope);
                 const paramsValueCapture = await maybeCaptureRequestValueAsync({
                     target: 'request.params',
                     rawValue: req.params,
@@ -4931,7 +5001,7 @@ function reproMiddleware(cfg) {
                         masking,
                         privacy: activePrivacy,
                     },
-                }, requestValueEntries);
+                }, requestValueEntries, captureScope);
                 const queryValueCapture = await maybeCaptureRequestValueAsync({
                     target: 'request.query',
                     rawValue: req.query,
@@ -4944,7 +5014,7 @@ function reproMiddleware(cfg) {
                         masking,
                         privacy: activePrivacy,
                     },
-                }, requestValueEntries);
+                }, requestValueEntries, captureScope);
                 const headersValueCapture = await maybeCaptureRequestValueAsync({
                     target: 'request.headers',
                     rawValue: req.headers,
@@ -4957,7 +5027,7 @@ function reproMiddleware(cfg) {
                         masking,
                         privacy: activePrivacy,
                     },
-                }, requestValueEntries);
+                }, requestValueEntries, captureScope);
                 const respBodyValueCapture = capturedBody === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
@@ -4972,7 +5042,7 @@ function reproMiddleware(cfg) {
                             masking,
                             privacy: activePrivacy,
                         },
-                    }, requestValueEntries);
+                    }, requestValueEntries, captureScope);
                 const responseDurationMs = finishedAt !== null && Number.isFinite(finishedAt)
                     ? Math.max(0, finishedAt - t0)
                     : Date.now() - t0;
@@ -5034,10 +5104,38 @@ function reproMiddleware(cfg) {
                                 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,
+                            }],
+                    });
                 }
             };
             const emitRequestCaptureManifest = (traceBatchTotal) => {
@@ -5151,6 +5249,7 @@ function reproMiddleware(cfg) {
                                 maskReq,
                                 masking,
                                 resolvePrivacy,
+                                captureScope,
                             });
                             const baseEvents = balanceTraceEvents(materializedEvents.slice());
                             const orderedEvents = TRACE_ORDER_MODE === 'tree'
@@ -5165,12 +5264,14 @@ function reproMiddleware(cfg) {
                             }
                         }
                         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 {
                             for (let i = 0; i < traceBatches.length; i++) {
                                 const batch = traceBatches[i];
@@ -5191,7 +5292,7 @@ function reproMiddleware(cfg) {
                             }
                         }
                         catch {
-                            // never break user code
+                            recordRequestCaptureFailure(captureScope, 'trace.enqueue', 'trace.batches', 'trace_enqueue_failed');
                         }
                     };
                 }
@@ -5758,6 +5859,11 @@ function emitDbQuery(cfg, sid, aid, payload) {
     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 = {
         sid: ctx.sid,
         aid: ctx.aid,
@@ -5769,7 +5875,9 @@ function emitDbQuery(cfg, sid, aid, payload) {
     };
     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' });
 }
@@ -5885,8 +5993,8 @@ async function emitDbQueryAsync(cfg, sid, aid, payload) {
                 t: payload.t,
             }]
     });
-    if (enqueued && ctx.captureScope) {
-        ctx.captureScope.dbChangeCount += 1;
+    if (!enqueued) {
+        recordRequestCaptureFailure(ctx.captureScope, 'db.enqueue', 'db.change', 'db_enqueue_failed');
     }
 }
 function buildMinimalUpdate(before, after) {
@@ -6293,8 +6401,8 @@ function cloneKafkaTelemetryValue(value) {
         return value;
     }
 }
-async function materializeKafkaRequestBody(cfg, maskReq, body) {
-    return materializeInlinePrivacyValueAsync('request.body', sanitizeInlinePrivacyValue(body), cfg, maskReq, null, normalizeMaskingConfig(cfg.masking), getRuntimePrivacyState(cfg).policy ?? null);
+async function materializeKafkaRequestBody(cfg, maskReq, body, captureScope) {
+    return materializeInlinePrivacyValueAsync('request.body', sanitizeInlinePrivacyValue(body), cfg, maskReq, null, normalizeMaskingConfig(cfg.masking), getRuntimePrivacyState(cfg).policy ?? null, undefined, captureScope);
 }
 function summarizeKafkaError(error) {
     const message = typeof error?.message === 'string'
@@ -6567,23 +6675,27 @@ function scheduleKafkaTraceFlush(cfg, kafkaCtx, actionId, requestRid, rawTraceEv
                 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 = [];
+            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 = 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: [{
@@ -6592,7 +6704,10 @@ function scheduleKafkaTraceFlush(cfg, kafkaCtx, actionId, requestRid, rawTraceEv
                             requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, entries.length),
                             t: alignedNow(),
                         }],
-                });
+                }, { priority: 'high' });
+            }
+            if (entries.length) {
+                post(cfg, sid, { entries });
             }
         });
     }, { priority: 'high' });
@@ -6610,7 +6725,7 @@ function patchKafkaProducerInstance(producer, cfg) {
             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.topic);
@@ -6669,7 +6784,7 @@ function patchKafkaProducerInstance(producer, cfg) {
                     traceId: span?.traceId ?? null,
                     spanId: span?.spanId ?? null,
                     parentSpanId: span?.parentSpanId ?? null,
-                });
+                }, captureScope);
                 const requestPayload = {
                     rid: publishRid,
                     method: 'KAFKA_PUBLISH',
@@ -6698,7 +6813,6 @@ function patchKafkaProducerInstance(producer, cfg) {
                         },
                     ],
                 });
-                captureScope.backendRequestCount += 1;
                 post(cfg, sid, {
                     entries: [{
                             actionId: aid ?? null,
@@ -6719,7 +6833,7 @@ function patchKafkaProducerInstance(producer, cfg) {
             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 topicMessages = Array.isArray(payloadObj.topicMessages)
@@ -6809,7 +6923,7 @@ function patchKafkaProducerInstance(producer, cfg) {
                     traceId: span?.traceId ?? null,
                     spanId: span?.spanId ?? null,
                     parentSpanId: span?.parentSpanId ?? null,
-                });
+                }, captureScope);
                 const requestPayload = {
                     rid: publishRid,
                     method: 'KAFKA_PUBLISH_BATCH',
@@ -6838,7 +6952,6 @@ function patchKafkaProducerInstance(producer, cfg) {
                         },
                     ],
                 });
-                captureScope.backendRequestCount += 1;
                 post(cfg, sid, {
                     entries: [{
                             actionId: aid ?? null,
@@ -6861,7 +6974,7 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
         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 = [];
         const maskReq = {
@@ -6939,7 +7052,7 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
                 valueEncoding: messagePayload.valueEncoding,
                 valueBytes: messagePayload.valueBytes,
                 message: messagePayload,
-            });
+            }, captureScope);
             const requestPayload = {
                 rid: consumeRid,
                 method: 'KAFKA_CONSUME',
@@ -6960,7 +7073,6 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
                         t: alignedNow(),
                     }],
             });
-            captureScope.backendRequestCount += 1;
             scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
         }
     };
@@ -6976,7 +7088,7 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
         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 = [];
         const maskReq = {
@@ -7052,7 +7164,7 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
                 parentSpanId: runtime.parentSpanId,
                 firstMessageKey: firstMessagePayload?.key ?? null,
                 messages: messages.map((message) => buildKafkaMessagePayload(message)),
-            });
+            }, captureScope);
             const requestPayload = {
                 rid: consumeRid,
                 method: 'KAFKA_CONSUME_BATCH',
@@ -7073,7 +7185,6 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
                         t: alignedNow(),
                     }],
             });
-            captureScope.backendRequestCount += 1;
             scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
         }
     };
@@ -7453,24 +7564,24 @@ function scheduleAmqpTraceFlush(cfg, amqpCtx, actionId, requestRid, rawTraceEven
                     pendingEvents.push(evt);
             }
             let entries = [];
-            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,
@@ -7478,7 +7589,10 @@ function scheduleAmqpTraceFlush(cfg, amqpCtx, actionId, requestRid, rawTraceEven
                         requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, entries.length),
                         t: alignedNow(),
                     }],
-            });
+            }, { priority: 'high' });
+            if (entries.length) {
+                post(cfg, sid, { entries });
+            }
         });
     }, { priority: 'high' });
 }
@@ -7524,7 +7638,7 @@ function scheduleAmqpPublishCapture(params) {
         parentSpanId: params.span?.parentSpanId ?? null,
     };
     scheduleSdkBackgroundWork(async () => {
-        const bodyMaterialization = await materializeKafkaRequestBody(params.cfg, maskReq, body);
+        const bodyMaterialization = await materializeKafkaRequestBody(params.cfg, maskReq, body, params.captureScope);
         const requestPayload = {
             rid: params.publishRid,
             method: params.method,
@@ -7554,7 +7668,6 @@ function scheduleAmqpPublishCapture(params) {
                     t: alignedNow(),
                 }],
         });
-        params.captureScope.backendRequestCount += 1;
         post(params.cfg, params.sid, {
             entries: [{
                     actionId: params.aid ?? null,
@@ -7605,7 +7718,7 @@ function patchAmqplibPublishMethod(channel, cfg, methodName) {
             : `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;
@@ -7692,7 +7805,7 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
         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 = [];
         const maskReq = {
@@ -7782,7 +7895,7 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
                 properties: buildAmqpMessagePropertiesPayload(properties),
             };
             scheduleSdkBackgroundWork(async () => {
-                const bodyMaterialization = await materializeKafkaRequestBody(cfg, maskReq, body);
+                const bodyMaterialization = await materializeKafkaRequestBody(cfg, maskReq, body, captureScope);
                 const requestPayload = {
                     rid: consumeRid,
                     method: 'AMQP_CONSUME',
@@ -7803,7 +7916,6 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
                             t: alignedNow(),
                         }],
                 });
-                captureScope.backendRequestCount += 1;
                 scheduleAmqpTraceFlush(cfg, amqpCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
             }, { priority: 'high' });
         };