@reproapp/node-sdk 0.0.49 → 0.0.51

package/src/index.ts

@@ -29,6 +29,7 @@ import {
     type RuntimePrivacyTraceContext,
 } from './privacy';
 import { projectSemanticInfrastructureValue } from './semantic-serialization';
+import { limitLiveCapture, limitLiveArguments, collectCaptureOmissions, type CaptureOmission } from './live-capture-limits';
 
 /**
  * ============================= IMPORTANT =============================
@@ -380,6 +381,8 @@ type PendingTraceEventRecord = TraceEventRecord & {
 };
 
 type TraceValueCaptureRef = {
+    complete?: boolean;
+    omissions?: CaptureOmission[];
     status:
         | 'stored'
         | 'truncated-for-storage'
@@ -419,6 +422,7 @@ type TraceValueBatchEntry = {
 };
 
 type TraceMaterializationConfig = {
+    captureMode?: 'live' | 'staging';
     tenantId: string;
     appId: string;
     appSecret?: string;
@@ -1213,6 +1217,7 @@ type NativeMongoSuppression = {
 };
 
 type RequestCaptureScopeState = {
+    liveCapture?: boolean;
     requestRid: string;
     transport: 'http' | 'kafka' | 'amqp' | 'background';
     backendRequestCount: number;
@@ -1246,6 +1251,7 @@ function createRequestCaptureScope(
     return {
         requestRid,
         transport,
+        liveCapture: cfg?.captureMode === 'live' || (!!cfg && cfg.captureMode !== 'staging' && !!normalizeLiveModeConfig(cfg)),
         // Every scope represents one captured transport request. This is an
         // observed expectation, not a count of successful enqueue operations.
         backendRequestCount: 1,
@@ -1546,8 +1552,9 @@ let activeClientRequestCount = 0;
 let oldestActiveClientRequestAt: number | null = null;
 let lastClientActivityAt = 0;
 let sdkBackgroundQuietUntil = 0;
-const sdkBackgroundHighQueue: Array<() => Promise<void> | void> = [];
-const sdkBackgroundQueue: Array<() => Promise<void> | void> = [];
+type SdkBackgroundWork = { work: () => Promise<void> | void; enqueuedAt: number };
+const sdkBackgroundHighQueue: SdkBackgroundWork[] = [];
+const sdkBackgroundQueue: SdkBackgroundWork[] = [];
 let sdkBackgroundTimer: NodeJS.Timeout | null = null;
 let sdkBackgroundDraining = false;
 let traceMaterializerWorker: any = null;
@@ -1569,23 +1576,25 @@ function noteClientActivity(now = Date.now()): void {
     lastClientActivityAt = now;
 }
 
-function getSdkBackgroundDelayMs(now = Date.now()): number {
+function getSdkBackgroundDelayMs(now = Date.now(), ingestEnqueuedAt?: number): number {
+    // Bound deferral by work age, not just by a continuously active request.
+    // Short non-overlapping requests reset oldestActiveClientRequestAt forever.
+    const oldestWorkAt = Math.min(
+        sdkBackgroundHighQueue[0]?.enqueuedAt ?? Infinity,
+        sdkBackgroundQueue[0]?.enqueuedAt ?? Infinity,
+        ingestEnqueuedAt ?? Infinity,
+        oldestActiveClientRequestAt ?? Infinity,
+    );
+    const remainingDeferMs = Number.isFinite(oldestWorkAt) && Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS)
+        ? Math.max(0, oldestWorkAt + SDK_BACKGROUND_MAX_DEFER_MS - now)
+        : Infinity;
     if (hasActiveClientRequests()) {
-        if (
-            oldestActiveClientRequestAt !== null &&
-            Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS) &&
-            SDK_BACKGROUND_MAX_DEFER_MS >= 0
-        ) {
-            const activeForMs = now - oldestActiveClientRequestAt;
-            if (activeForMs >= SDK_BACKGROUND_MAX_DEFER_MS) return 0;
-            return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, Math.max(0, SDK_BACKGROUND_MAX_DEFER_MS - activeForMs));
-        }
-        return SDK_BACKGROUND_IDLE_DELAY_MS;
+        return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, remainingDeferMs);
     }
     const sinceLastActivity = now - lastClientActivityAt;
     const idleDelayRemaining = Math.max(0, SDK_BACKGROUND_IDLE_DELAY_MS - sinceLastActivity);
     const quietWindowRemaining = Math.max(0, sdkBackgroundQuietUntil - now);
-    return Math.max(idleDelayRemaining, quietWindowRemaining);
+    return Math.min(Math.max(idleDelayRemaining, quietWindowRemaining), remainingDeferMs);
 }
 
 function shouldDeferSdkBackgroundWork(now = Date.now()): boolean {
@@ -1798,10 +1807,8 @@ function beginClientRequest(): void {
         oldestActiveClientRequestAt = now;
     }
     activeClientRequestCount += 1;
-    if (sdkBackgroundTimer) {
-        try { clearTimeout(sdkBackgroundTimer); } catch {}
-        sdkBackgroundTimer = null;
-    }
+    // The scheduled drain rechecks activity; cancelling it here loses the
+    // queued work's deadline under sustained traffic.
 }
 
 function endClientRequest(): void {
@@ -1822,15 +1829,17 @@ function scheduleSdkBackgroundWork(
     work: () => Promise<void> | void,
     options: { priority?: 'high' | 'normal' } = {},
 ): void {
+    const item = { work, enqueuedAt: Date.now() };
     if (options.priority === 'high') {
-        sdkBackgroundHighQueue.push(work);
+        sdkBackgroundHighQueue.push(item);
     } else {
-        sdkBackgroundQueue.push(work);
+        sdkBackgroundQueue.push(item);
     }
     scheduleSdkBackgroundDrain();
 }
 
 function scheduleSdkBackgroundDrain(delayMs = 0): void {
+    if (!sdkBackgroundHighQueue.length && !sdkBackgroundQueue.length) return;
     if (sdkBackgroundTimer) return;
     const nextDelay = Math.max(delayMs, getSdkBackgroundDelayMs());
     sdkBackgroundTimer = setTimeout(() => {
@@ -1865,11 +1874,11 @@ async function drainSdkBackgroundQueue(): Promise<void> {
                 scheduleSdkBackgroundDrain();
                 return;
             }
-            const work = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
-            if (!work) continue;
+            const item = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
+            if (!item) continue;
             try {
                 await drainQueuedIngestBeforeBackgroundWork();
-                await runSdkBackgroundWork(work);
+                await runSdkBackgroundWork(item.work);
             } catch {
                 // never break user code
             }
@@ -1885,8 +1894,8 @@ async function drainSdkBackgroundQueue(): Promise<void> {
 }
 
 configureIngestQueueDrain({
-    shouldDefer: shouldDeferSdkBackgroundWork,
-    deferMs: SDK_BACKGROUND_IDLE_DELAY_MS,
+    shouldDefer: (enqueuedAt) => getSdkBackgroundDelayMs(Date.now(), enqueuedAt) > 0,
+    deferMs: Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, SDK_BACKGROUND_MAX_DEFER_MS),
 });
 
 // Track in-flight requests per session so we can delay flushing until a session is drained.
@@ -2599,6 +2608,7 @@ async function resolveBackendLiveContext(
         liveMode,
         '/v1/live-sessions/claim',
         {
+            liveCapture: liveMode.liveCapture,
             clientTime: requestStart,
             captureMode: 'backend-only',
             actorId,
@@ -2712,6 +2722,7 @@ function stripReproQueryFromUrl(rawUrl: string): string {
         parsed.searchParams.delete(REPRO_QUERY_SESSION_PARAM);
         parsed.searchParams.delete(REPRO_QUERY_ACTION_PARAM);
         parsed.searchParams.delete(REPRO_QUERY_START_PARAM);
+        parsed.searchParams.delete('__repro_mode');
         return `${parsed.pathname}${parsed.search}${parsed.hash}`;
     } catch {
         return rawUrl;
@@ -2725,6 +2736,7 @@ function stripReproQueryParams(req: Request): void {
             delete query[REPRO_QUERY_SESSION_PARAM];
             delete query[REPRO_QUERY_ACTION_PARAM];
             delete query[REPRO_QUERY_START_PARAM];
+            delete query.__repro_mode;
         }
     } catch {}
     try {
@@ -3439,6 +3451,11 @@ function snapshotTraceValueAtObservation(
     target = 'trace.value',
 ): any {
     try {
+        if (captureScope?.liveCapture) {
+            value = target === 'trace.args' && Array.isArray(value)
+                ? limitLiveArguments(value)
+                : limitLiveCapture(value, valuePath).value;
+        }
         const snapshot = sanitizeTraceValue(
             value,
             0,
@@ -3714,6 +3731,7 @@ async function materializePendingTraceEventsAsync(
                 appSecret: params.cfg.appSecret,
                 appName: params.cfg.appName,
                 privacy: params.cfg.privacy,
+                captureMode: params.captureScope?.liveCapture ? 'live' : params.cfg.captureMode,
             },
             maskReq: params.maskReq,
             masking: params.masking,
@@ -4223,6 +4241,18 @@ async function initializeRuntimePrivacyPolicyAtStartup(cfg: ReproMiddlewareConfi
     );
 }
 
+function isLiveCapture(cfg: ReproMiddlewareConfig, scope?: RequestCaptureScopeState | null): boolean {
+    if (scope) return scope.liveCapture === true;
+    return cfg.captureMode === 'live' || (cfg.captureMode !== 'staging' && getCtx().captureScope?.liveCapture === true);
+}
+
+function constrainLiveCapture(value: any, cfg: ReproMiddlewareConfig, target: string, scope?: RequestCaptureScopeState | null): any {
+    if (!isLiveCapture(cfg, scope)) return value;
+    return target === 'trace.args' && Array.isArray(value)
+        ? limitLiveArguments(value)
+        : limitLiveCapture(value).value;
+}
+
 function applyPrivacyThenMask(
     target: RuntimePrivacySurface,
     value: any,
@@ -4233,6 +4263,7 @@ function applyPrivacyThenMask(
     privacy: NormalizedRuntimePrivacyPolicy | null,
     db?: RuntimePrivacyDbContext | null,
 ) {
+    value = constrainLiveCapture(value, cfg, target);
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
@@ -4263,6 +4294,7 @@ async function applyPrivacyThenMaskAsync(
     privacy: NormalizedRuntimePrivacyPolicy | null,
     db?: RuntimePrivacyDbContext | null,
 ) {
+    value = constrainLiveCapture(value, cfg, target);
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
@@ -4342,6 +4374,7 @@ function materializeInlinePrivacyValue(
     db?: RuntimePrivacyDbContext | null,
     captureScope?: RequestCaptureScopeState | null,
 ): InlinePrivacyMaterializationResult {
+    value = constrainLiveCapture(value, cfg, target, captureScope);
     if (value === undefined) {
         return { value };
     }
@@ -4381,6 +4414,7 @@ async function materializeInlinePrivacyValueAsync(
     db?: RuntimePrivacyDbContext | null,
     captureScope?: RequestCaptureScopeState | null,
 ): Promise<InlinePrivacyMaterializationResult> {
+    value = constrainLiveCapture(value, cfg, target, captureScope);
     if (value === undefined) {
         return { value };
     }
@@ -5549,6 +5583,9 @@ function createCapturedValueEntry(
 ): { captureRef: TraceValueCaptureRef; entry?: TraceValueBatchEntry } | undefined {
     if (!__FULL_VALUE_CAPTURE_ENABLED) return undefined;
 
+    const limitedRaw = constrainLiveCapture(params.rawValue, params.capture.runtimeConfig, params.target);
+    const omissions = isLiveCapture(params.capture.runtimeConfig) ? collectCaptureOmissions(limitedRaw) : [];
+
     const preferredLimits: FullValueCloneLimits = {
         maxDepth: TRACE_FULL_VALUE_MAX_DEPTH,
         maxKeys: TRACE_FULL_VALUE_MAX_KEYS,
@@ -5558,7 +5595,7 @@ function createCapturedValueEntry(
     const buildMaskedCandidate = (limits: FullValueCloneLimits) => {
         const projected = params.target === 'request.headers'
             ? sanitizeHeaders(params.rawValue, params.capture.captureHeaders)
-            : cloneFullValueCandidate(params.rawValue, params.capture, limits);
+            : cloneFullValueCandidate(limitedRaw, params.capture, limits);
         if (projected === undefined) return undefined;
         return applyPrivacyThenMask(
             params.target,
@@ -5579,7 +5616,7 @@ function createCapturedValueEntry(
     }
 
     const candidateSerialized = stableSerializeTraceValue(candidate);
-    if (!candidateSerialized || candidateSerialized === previewSerialized) {
+    if (!candidateSerialized || (candidateSerialized === previewSerialized && !omissions.length)) {
         return undefined;
     }
 
@@ -5605,6 +5642,7 @@ function createCapturedValueEntry(
             status: 'stored',
             valueId,
             projectedKind: entry.projectedKind,
+            ...(omissions.length ? { complete: false, omissions } : {}),
         },
         entry,
     };
@@ -5635,6 +5673,9 @@ async function createCapturedValueEntryAsync(
 ): Promise<{ captureRef: TraceValueCaptureRef; entry?: TraceValueBatchEntry } | undefined> {
     if (!__FULL_VALUE_CAPTURE_ENABLED) return undefined;
 
+    const limitedRaw = constrainLiveCapture(params.rawValue, params.capture.runtimeConfig, params.target);
+    const omissions = isLiveCapture(params.capture.runtimeConfig) ? collectCaptureOmissions(limitedRaw) : [];
+
     const preferredLimits: FullValueCloneLimits = {
         maxDepth: TRACE_FULL_VALUE_MAX_DEPTH,
         maxKeys: TRACE_FULL_VALUE_MAX_KEYS,
@@ -5644,7 +5685,7 @@ async function createCapturedValueEntryAsync(
     const buildMaskedCandidate = async (limits: FullValueCloneLimits) => {
         const projected = params.target === 'request.headers'
             ? sanitizeHeaders(params.rawValue, params.capture.captureHeaders)
-            : await cloneFullValueCandidateAsync(params.rawValue, params.capture, limits);
+            : await cloneFullValueCandidateAsync(limitedRaw, params.capture, limits);
         if (projected === undefined) return undefined;
         return applyPrivacyThenMaskAsync(
             params.target,
@@ -5665,7 +5706,7 @@ async function createCapturedValueEntryAsync(
     }
 
     const candidateSerialized = stableSerializeTraceValue(candidate);
-    if (!candidateSerialized || candidateSerialized === previewSerialized) {
+    if (!candidateSerialized || (candidateSerialized === previewSerialized && !omissions.length)) {
         return undefined;
     }
 
@@ -5691,6 +5732,7 @@ async function createCapturedValueEntryAsync(
             status: 'stored',
             valueId,
             projectedKind: entry.projectedKind,
+            ...(omissions.length ? { complete: false, omissions } : {}),
         },
         entry,
     };
@@ -5892,6 +5934,8 @@ async function maybeCaptureDbValueFromCandidatesAsync(
 // reproMiddleware — unchanged behavior + passive per-request trace
 // ===================================================================
 export type ReproMiddlewareConfig = IngestClientConfig & {
+    /** Propagated recording mode. A tagged staging request never inherits live limits. */
+    captureMode?: 'live' | 'staging';
     /** API base used for backend-owned live session documents. Defaults to REPRO_API_BASE_URL/REPRO_API_BASE/privacy.apiBase. */
     apiBase?: string;
     /** Configure header capture/masking. Defaults to capturing with sensitive headers masked. */
@@ -5923,6 +5967,11 @@ export type ReproLiveActorDecision = ReproLiveActorArgs & {
 };
 
 export type ReproLiveModeConfig = {
+    /** Stable chain sampling. Runtime updates apply to new chains; targets are evaluated on each claim. */
+    liveCapture?: {
+        sampleRate?: number;
+        targets?: { actorIds?: string[]; labels?: Record<string, string>; expiresAt: number }[];
+    };
     enabled?: boolean;
     backendOnly?: boolean;
     /**
@@ -6112,6 +6161,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
         const querySid = readRequestQueryParam(req, REPRO_QUERY_SESSION_PARAM);
         const queryAid = readRequestQueryParam(req, REPRO_QUERY_ACTION_PARAM);
         const queryTs = readRequestQueryNumber(req, REPRO_QUERY_START_PARAM);
+        const queryCaptureMode = readRequestQueryParam(req, '__repro_mode');
         if (querySid || queryAid || queryTs !== null) {
             stripReproQueryParams(req);
         }
@@ -6181,6 +6231,11 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                 }],
             }, { priority: 'high' });
         }
+        const captureMode = backendLiveContext || req.headers['x-repro-capture-mode'] === 'live' || queryCaptureMode === 'live'
+            ? 'live' : 'staging';
+        const modeConfig = { ...captureCfg, captureMode } as ReproMiddlewareConfig;
+        shareRuntimePrivacyState(captureCfg, modeConfig);
+        captureCfg = modeConfig;
         const resolvePrivacy = (): NormalizedRuntimePrivacyPolicy | null =>
             getRuntimePrivacyState(captureCfg).policy ?? null;
 
@@ -7745,6 +7800,7 @@ function patchNodeFetchForPropagation() {
         if (runtime.aid && !hasHttpHeader(headers, KAFKA_HEADER_ACTION_ID)) {
             setHttpHeader(headers, KAFKA_HEADER_ACTION_ID, runtime.aid);
         }
+        if (runtime.sid) setHttpHeader(headers, 'x-repro-capture-mode', getCtx().captureScope?.liveCapture ? 'live' : 'staging');
         if (runtime.traceId && !hasHttpHeader(headers, KAFKA_HEADER_TRACE_ID)) {
             setHttpHeader(headers, KAFKA_HEADER_TRACE_ID, runtime.traceId);
         }
@@ -7799,6 +7855,7 @@ function patchNodeHttpModuleRequest(mod: any) {
             maybeSet(REQUEST_START_HEADER, String(alignedNow()));
             maybeSet(KAFKA_HEADER_SESSION_ID, runtime.sid);
             maybeSet(KAFKA_HEADER_ACTION_ID, runtime.aid);
+            if (runtime.sid) maybeSet('x-repro-capture-mode', getCtx().captureScope?.liveCapture ? 'live' : 'staging');
             maybeSet(KAFKA_HEADER_TRACE_ID, runtime.traceId);
             maybeSet(KAFKA_HEADER_PARENT_SPAN_ID, runtime.parentSpanId);
             maybeSet(KAFKA_HEADER_REQUEST_ID, runtime.requestRid);
@@ -7826,6 +7883,7 @@ type KafkaHeaderValue = string | Buffer | null | undefined;
 type KafkaHeaderMap = Record<string, KafkaHeaderValue>;
 type KafkaContextResolver = () => { sid?: string; aid?: string } | undefined;
 type KafkaPropagationContext = {
+    captureMode?: 'live' | 'staging';
     sid: string | null;
     aid: string | null;
     traceId: string | null;
@@ -7990,6 +8048,11 @@ async function materializeKafkaRequestBody(
     body: Record<string, any>,
     captureScope?: RequestCaptureScopeState | null,
 ): Promise<InlinePrivacyMaterializationResult> {
+    // Broker bodies have no separate full-value reference. Returning the trace
+    // inline preview here would permanently replace message arrays with 20 items.
+    if (shouldCapturePrivacyRaw(cfg)) {
+        return { value: constrainLiveCapture(sanitizeInlinePrivacyValue(body), cfg, 'request.body', captureScope) };
+    }
     return materializeInlinePrivacyValueAsync(
         'request.body',
         sanitizeInlinePrivacyValue(body),
@@ -8053,7 +8116,8 @@ function resolveKafkaContext(cfg: KafkaJsPatchConfig, headers: any): KafkaPropag
         null;
     const requestRid = readKafkaHeader(headers, KAFKA_HEADER_REQUEST_ID);
 
-    return { sid, aid, traceId, parentSpanId, requestRid };
+    return { sid, aid, traceId, parentSpanId, requestRid,
+        captureMode: readKafkaHeader(headers, 'x-repro-capture-mode') === 'live' || ctx.captureScope?.liveCapture ? 'live' : 'staging' };
 }
 
 function withOptionalTraceContext<T>(traceId: string | null, fn: () => Promise<T>): Promise<T> {
@@ -8420,6 +8484,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                         [KAFKA_HEADER_REQUEST_ID]: publishRid,
                         [KAFKA_HEADER_SESSION_ID]: sid,
                         [KAFKA_HEADER_ACTION_ID]: aid,
+                        'x-repro-capture-mode': ctx.captureScope?.liveCapture ? 'live' : 'staging',
                     }),
                 };
             });
@@ -8552,6 +8617,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                                 [KAFKA_HEADER_REQUEST_ID]: publishRid,
                                 [KAFKA_HEADER_SESSION_ID]: sid,
                                 [KAFKA_HEADER_ACTION_ID]: aid,
+                                'x-repro-capture-mode': ctx.captureScope?.liveCapture ? 'live' : 'staging',
                             }),
                         };
                     }),
@@ -8668,6 +8734,7 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
         const consumeRid = nextRequestId(`${topic}-${message?.offset ?? alignedNow()}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'kafka', cfg);
+        captureScope.liveCapture = runtime.captureMode === 'live';
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
@@ -8778,6 +8845,7 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
         const consumeRid = nextRequestId(`${topic}-batch-${alignedNow()}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'kafka', cfg);
+        captureScope.liveCapture = runtime.captureMode === 'live';
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
@@ -8972,6 +9040,7 @@ export function patchKafkaJs(cfg: KafkaJsPatchConfig) {
 type AmqpHeaderMap = Record<string, any>;
 type AmqpContextResolver = () => { sid?: string; aid?: string } | undefined;
 type AmqpPropagationContext = {
+    captureMode?: 'live' | 'staging';
     sid: string | null;
     aid: string | null;
     traceId: string | null;
@@ -9240,7 +9309,8 @@ function resolveAmqpContext(cfg: AmqplibPatchConfig, headers: any): AmqpPropagat
         null;
     const requestRid = readAmqpHeader(headers, KAFKA_HEADER_REQUEST_ID);
 
-    return { sid, aid, traceId, parentSpanId, requestRid };
+    return { sid, aid, traceId, parentSpanId, requestRid,
+        captureMode: readAmqpHeader(headers, 'x-repro-capture-mode') === 'live' || ctx.captureScope?.liveCapture ? 'live' : 'staging' };
 }
 
 function withOptionalTraceContextSync<T>(traceId: string | null, fn: () => T): T {
@@ -9478,6 +9548,7 @@ function patchAmqplibPublishMethod(
             [KAFKA_HEADER_REQUEST_ID]: publishRid,
             [KAFKA_HEADER_SESSION_ID]: sid,
             [KAFKA_HEADER_ACTION_ID]: aid,
+            'x-repro-capture-mode': ctx.captureScope?.liveCapture ? 'live' : 'staging',
         };
         const shouldPropagate = hasAmqpPropagationValues(propagationValues);
         const callbackIndex = args.length > 0 && typeof args[args.length - 1] === 'function'
@@ -9586,6 +9657,7 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
         const consumeRid = nextRequestId(`${queueName}-${deliveryTag}`);
         const traceId = consumeRid;
         const captureScope = createRequestCaptureScope(consumeRid, 'amqp', cfg);
+        captureScope.liveCapture = runtime.captureMode === 'live';
         emitRequestCaptureStart(cfg, sid, aid, captureScope);
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {

package/src/ingest/client.ts

@@ -44,6 +44,7 @@ type QueuedIngestBatch = {
     sessionId: string;
     entries: LegacyEntry[];
     attempts: number;
+    enqueuedAt: number;
     priority: 'normal' | 'high' | 'critical';
 };
 
@@ -59,11 +60,13 @@ let draining = false;
 let criticalDraining = false;
 let backoffMs = 0;
 let criticalBackoffMs = 0;
-let shouldDeferDrain: (() => boolean) | null = null;
+let shouldDeferDrain: ((enqueuedAt?: number) => boolean) | null = null;
 let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
+const throttledUntil = new Map<string, number>();
+const throttleDelay = (config: IngestClientConfig) => Math.max(0, (throttledUntil.get(resolveIngestUrl(config)) ?? 0) - Date.now());
 
 export const configureIngestQueueDrain = (options: {
-    shouldDefer?: (() => boolean) | null;
+    shouldDefer?: ((enqueuedAt?: number) => boolean) | null;
     deferMs?: number;
 }): void => {
     shouldDeferDrain = options.shouldDefer ?? null;
@@ -77,7 +80,7 @@ export const kickIngestQueueDrain = (): void => {
         scheduleCriticalDrain();
     }
     if (ingestQueue.length > 0 && !drainTimer) {
-        scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+        scheduleDrain(shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt) ? deferDrainMs : 0);
     }
 };
 
@@ -220,7 +223,9 @@ const sendIngestEntries = async (
     config: IngestClientConfig,
     sessionId: string,
     entries: LegacyEntry[],
-): Promise<boolean> => {
+): Promise<boolean | 'throttled' | 'denied'> => {
+    if (throttleDelay(config) > 0) return 'throttled';
+    throttledUntil.delete(resolveIngestUrl(config));
     if (!sessionId || !Array.isArray(entries) || entries.length === 0) {
         return true;
     }
@@ -255,6 +260,18 @@ const sendIngestEntries = async (
             body: JSON.stringify({ events }),
             ...(controller ? { signal: controller.signal } : {}),
         });
+        if (response.status === 429) {
+            const retryAfter = response.headers?.get?.('retry-after');
+            const seconds = retryAfter ? Number(retryAfter) : NaN;
+            const date = retryAfter ? Date.parse(retryAfter) : NaN;
+            const delay = Number.isFinite(seconds) ? seconds * 1000 : Number.isFinite(date) ? date - Date.now() : 1000;
+            throttledUntil.set(resolveIngestUrl(config), Date.now() + Math.max(1000, Math.min(86400_000, delay)));
+            return 'throttled';
+        }
+        if (response.status === 402 || response.status === 410) {
+            console.warn(`[repro] Upload refused for ${sessionId}: ${response.status === 402 ? 'capture quota exhausted' : 'capture deleted, expired or failed'}. This batch will not be retried.`);
+            return 'denied';
+        }
         return response.ok;
     } catch {
         // swallow in SDK
@@ -272,12 +289,12 @@ const scheduleDrain = (delayMs = 0): void => {
     if (drainTimer) {
         return;
     }
-    const nextDelay = shouldDeferDrain?.()
+    const nextDelay = shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)
         ? Math.max(delayMs, deferDrainMs)
         : delayMs;
     drainTimer = setTimeout(() => {
         drainTimer = null;
-        if (shouldDeferDrain?.()) {
+        if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
             scheduleDrain(deferDrainMs);
             return;
         }
@@ -317,7 +334,11 @@ const drainCriticalIngestQueue = async (): Promise<void> => {
                 selected.batch.sessionId,
                 selected.batch.entries,
             );
-            if (ok) {
+            if (ok === 'throttled') {
+                scheduleCriticalDrain(throttleDelay(selected.batch.config));
+                return;
+            }
+            if (ok === true || ok === 'denied') {
                 criticalIngestQueue.splice(0, selected.queueItems);
                 criticalBackoffMs = 0;
                 continue;
@@ -345,14 +366,14 @@ const drainIngestQueue = async (): Promise<void> => {
     if (draining) {
         return;
     }
-    if (shouldDeferDrain?.()) {
+    if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
         scheduleDrain(deferDrainMs);
         return;
     }
     draining = true;
     try {
         while (ingestQueue.length > 0) {
-            if (shouldDeferDrain?.()) {
+            if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
                 scheduleDrain(deferDrainMs);
                 return;
             }
@@ -362,7 +383,11 @@ const drainIngestQueue = async (): Promise<void> => {
             }
             const batch = selected.batch;
             const ok = await sendIngestEntries(batch.config, batch.sessionId, batch.entries);
-            if (ok) {
+            if (ok === 'throttled') {
+                scheduleDrain(throttleDelay(batch.config));
+                return;
+            }
+            if (ok === true || ok === 'denied') {
                 ingestQueue.splice(0, selected.queueItems);
                 backoffMs = 0;
                 continue;
@@ -420,6 +445,7 @@ export const enqueueIngestEntries = (
         sessionId,
         entries: entries.slice(),
         attempts: 0,
+        enqueuedAt: Date.now(),
         priority,
     };
     if (priority === 'critical') {