@reproapp/node-sdk 0.0.49 → 0.0.51

package/README.md

@@ -107,6 +107,7 @@ await initRepro({
   appName: "Acme Web",
   serviceName: "api",
   apiBase: process.env.REPRO_API_BASE,
+  ingestBase: process.env.REPRO_INGEST_BASE!,
 });
 ```
 
@@ -123,14 +124,56 @@ await initRepro({
   liveMode: {
     enabled: true,
     backendOnly: true,
-    defineActorId: ({ req, ip }) => req.headers["x-user-id"] ?? (ip ? `ip:${ip}` : null),
+    // Trust only a header that your authenticated gateway overwrites.
+    defineActorId: ({ req }) => req.headers["x-user-id"] ?? null,
     shouldCapture: ({ path }) => path.startsWith("/api/") && !path.includes("/health"),
     actorType: "user",
     actorLabels: ({ path }) => ({ routeGroup: path.split("/").filter(Boolean)[0] ?? "api" }),
+    liveCapture: { sampleRate: 0.1, targets: [] },
   },
 });
 ```
 
+### Sampling, limits and runtime targets
+
+Backend-owned live capture accepts `liveMode.liveCapture.sampleRate` from 0 to 1
+(default 1 for compatibility). A chain keeps its sample decision until five minutes
+of inactivity. Actor identity separates chains; three-minute child segments admit
+new work. Admitted requests and their queue/DB/trace tails stay in the original
+segment even when delivery finishes later. Browser-correlated captures use the
+browser's admission decision, rather than sampling a second time.
+
+Keep the `liveCapture` object in your runtime configuration and replace its `targets`
+array when a support case starts or ends. Example target entries:
+
+```ts
+const liveCapture = {
+  sampleRate: 0.1,
+  targets: [
+    { actorIds: ['user-123'], expiresAt: Date.now() + 3600000 },
+    { labels: { routeGroup: 'reports' }, expiresAt: Date.now() + 3600000 },
+  ],
+};
+// Pass this object as liveMode.liveCapture; update liveCapture.targets at runtime.
+```
+
+Targets override sampling, including rate 0, but never quota admission. All labels
+in one target must match; actor IDs and label selectors are alternatives. Use a
+trusted identity source, not arbitrary client-controlled headers.
+
+Live business values have depth 10, 100 keys per object, and 100 entries per array,
+Map, Set or native collection. Partial captures carry explicit omitted path/reason/
+count metadata. `captureRaw: true` bypasses privacy processing, not live limits.
+Staging business values are unchanged. Both modes project recognized runtime
+infrastructure (connections, pools, framework/configuration machinery) into compact
+descriptions; business documents, queries, results and application payloads remain
+evidence. Unknown objects are treated as business data.
+
+HTTP 429 honors `Retry-After` without dropping critical uploads. Quota refusal (402)
+and deleted/failed capture refusal (410) stop retrying that refused batch; business
+requests continue. Quota-enabled installations must use the configured collector,
+not the legacy direct API evidence endpoints.
+
 ## Manual Wiring
 
 Use the lower-level exports when auto-attach is not appropriate or when you need

package/dist/index.d.ts

@@ -28,6 +28,7 @@ import type { Schema } from 'mongoose';
 import { type IngestClientConfig } from './ingest/client';
 import { type NormalizedRuntimePrivacyPolicy, type RuntimePrivacyConfig, type RuntimePrivacyDbContext, type RuntimePrivacySurface } from './privacy';
 import { projectSemanticInfrastructureValue } from './semantic-serialization';
+import { type CaptureOmission } from './live-capture-limits';
 type SpanContext = {
     traceId: string | null;
     spanId: string | number | null;
@@ -88,6 +89,8 @@ type PendingTraceEventRecord = TraceEventRecord & {
     __reproTraceValueEntries?: TraceValueBatchEntry[];
 };
 type TraceValueCaptureRef = {
+    complete?: boolean;
+    omissions?: CaptureOmission[];
     status: 'stored' | 'truncated-for-storage' | 'skipped-non-meaningful' | 'failed-policy';
     valueId?: string;
     projectedKind?: string;
@@ -107,6 +110,7 @@ type TraceValueBatchEntry = {
     eventIndex?: number;
 };
 type TraceMaterializationConfig = {
+    captureMode?: 'live' | 'staging';
     tenantId: string;
     appId: string;
     appSecret?: string;
@@ -284,6 +288,7 @@ type NativeMongoSuppression = {
     ownerStore?: Ctx;
 };
 type RequestCaptureScopeState = {
+    liveCapture?: boolean;
     requestRid: string;
     transport: 'http' | 'kafka' | 'amqp' | 'background';
     backendRequestCount: number;
@@ -342,6 +347,8 @@ declare function getEventTraceValueEntries(event: TraceEventRecord | PendingTrac
 declare function estimateTraceBatchSerializedBytes(batch: TraceEventRecord[], requestRid: string, actionId: string | null | undefined, batchIndex: number, previouslyEmittedValueIds?: ReadonlySet<string>): number;
 declare function chunkTraceEventsForTransport(events: TraceEventRecord[], requestRid: string, actionId: string | null | undefined): TraceEventRecord[][];
 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. */
@@ -370,6 +377,15 @@ export type ReproLiveActorDecision = ReproLiveActorArgs & {
     actorLabels?: Record<string, string>;
 };
 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;
     /**

package/dist/index.js

@@ -10,6 +10,7 @@ const url_1 = require("url");
 const client_1 = require("./ingest/client");
 const privacy_1 = require("./privacy");
 const semantic_serialization_1 = require("./semantic-serialization");
+const live_capture_limits_1 = require("./live-capture-limits");
 /**
  * ============================= IMPORTANT =============================
  * We snapshot Mongoose core methods BEFORE tracer init, then re-apply them
@@ -828,6 +829,7 @@ function createRequestCaptureScope(requestRid, transport, cfg) {
     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,
@@ -1119,22 +1121,20 @@ function hasActiveClientRequests() {
 function noteClientActivity(now = Date.now()) {
     lastClientActivityAt = now;
 }
-function getSdkBackgroundDelayMs(now = Date.now()) {
+function getSdkBackgroundDelayMs(now = Date.now(), ingestEnqueuedAt) {
+    // 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()) {
     return getSdkBackgroundDelayMs(now) > 0;
@@ -1370,13 +1370,8 @@ function beginClientRequest() {
         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() {
     activeClientRequestCount = Math.max(0, activeClientRequestCount - 1);
@@ -1395,15 +1390,18 @@ function endClientRequest() {
     }
 }
 function scheduleSdkBackgroundWork(work, options = {}) {
+    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) {
+    if (!sdkBackgroundHighQueue.length && !sdkBackgroundQueue.length)
+        return;
     if (sdkBackgroundTimer)
         return;
     const nextDelay = Math.max(delayMs, getSdkBackgroundDelayMs());
@@ -1439,12 +1437,12 @@ async function drainSdkBackgroundQueue() {
                 scheduleSdkBackgroundDrain();
                 return;
             }
-            const work = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
-            if (!work)
+            const item = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
+            if (!item)
                 continue;
             try {
                 await drainQueuedIngestBeforeBackgroundWork();
-                await runSdkBackgroundWork(work);
+                await runSdkBackgroundWork(item.work);
             }
             catch {
                 // never break user code
@@ -1462,8 +1460,8 @@ async function drainSdkBackgroundQueue() {
     }
 }
 (0, client_1.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.
 const sessionInFlight = new Map();
@@ -2054,6 +2052,7 @@ async function resolveBackendLiveContext(cfg, req, requestStart) {
     }
     const { actorId, actorType, actorLabels } = identity;
     const claim = await postLiveApiJson(cfg, liveMode, '/v1/live-sessions/claim', {
+        liveCapture: liveMode.liveCapture,
         clientTime: requestStart,
         captureMode: 'backend-only',
         actorId,
@@ -2156,6 +2155,7 @@ function stripReproQueryFromUrl(rawUrl) {
         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 {
@@ -2169,6 +2169,7 @@ function stripReproQueryParams(req) {
             delete query[REPRO_QUERY_SESSION_PARAM];
             delete query[REPRO_QUERY_ACTION_PARAM];
             delete query[REPRO_QUERY_START_PARAM];
+            delete query.__repro_mode;
         }
     }
     catch { }
@@ -2834,6 +2835,11 @@ function internTraceObservationSnapshot(snapshot, captureScope) {
 }
 function snapshotTraceValueAtObservation(value, captureScope, valuePath = '$', target = 'trace.value') {
     try {
+        if (captureScope?.liveCapture) {
+            value = target === 'trace.args' && Array.isArray(value)
+                ? (0, live_capture_limits_1.limitLiveArguments)(value)
+                : (0, live_capture_limits_1.limitLiveCapture)(value, valuePath).value;
+        }
         const snapshot = sanitizeTraceValue(value, 0, new WeakMap(), { preserveLongStrings: true, disableTruncation: true }, valuePath);
         return internTraceObservationSnapshot(snapshot, captureScope);
     }
@@ -3018,6 +3024,7 @@ async function materializePendingTraceEventsAsync(events, params) {
                 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,
@@ -3439,7 +3446,20 @@ async function initializeRuntimePrivacyPolicyAtStartup(cfg) {
     }
     throw new Error(`Runtime privacy policy failed to load during startup from ${apiBase} for env ${state.environment} (${lastFailure}).`);
 }
+function isLiveCapture(cfg, scope) {
+    if (scope)
+        return scope.liveCapture === true;
+    return cfg.captureMode === 'live' || (cfg.captureMode !== 'staging' && getCtx().captureScope?.liveCapture === true);
+}
+function constrainLiveCapture(value, cfg, target, scope) {
+    if (!isLiveCapture(cfg, scope))
+        return value;
+    return target === 'trace.args' && Array.isArray(value)
+        ? (0, live_capture_limits_1.limitLiveArguments)(value)
+        : (0, live_capture_limits_1.limitLiveCapture)(value).value;
+}
 function applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy, db) {
+    value = constrainLiveCapture(value, cfg, target);
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
@@ -3460,6 +3480,7 @@ function applyPrivacyThenMask(target, value, cfg, req, trace, masking, privacy,
     return applyMasking(target, transformed, req, trace, masking);
 }
 async function applyPrivacyThenMaskAsync(target, value, cfg, req, trace, masking, privacy, db) {
+    value = constrainLiveCapture(value, cfg, target);
     if (shouldCapturePrivacyRaw(cfg)) {
         return value;
     }
@@ -3506,6 +3527,7 @@ function limitRawInlinePrivacyValue(target, value) {
     return limited.skipped ? limited : null;
 }
 function materializeInlinePrivacyValue(target, value, cfg, req, trace, masking, privacy, db, captureScope) {
+    value = constrainLiveCapture(value, cfg, target, captureScope);
     if (value === undefined) {
         return { value };
     }
@@ -3529,6 +3551,7 @@ function materializeInlinePrivacyValue(target, value, cfg, req, trace, masking,
     }
 }
 async function materializeInlinePrivacyValueAsync(target, value, cfg, req, trace, masking, privacy, db, captureScope) {
+    value = constrainLiveCapture(value, cfg, target, captureScope);
     if (value === undefined) {
         return { value };
     }
@@ -4505,6 +4528,8 @@ function boundTraceEventsForTransport(events) {
 function createCapturedValueEntry(params) {
     if (!__FULL_VALUE_CAPTURE_ENABLED)
         return undefined;
+    const limitedRaw = constrainLiveCapture(params.rawValue, params.capture.runtimeConfig, params.target);
+    const omissions = isLiveCapture(params.capture.runtimeConfig) ? (0, live_capture_limits_1.collectCaptureOmissions)(limitedRaw) : [];
     const preferredLimits = {
         maxDepth: TRACE_FULL_VALUE_MAX_DEPTH,
         maxKeys: TRACE_FULL_VALUE_MAX_KEYS,
@@ -4514,7 +4539,7 @@ function createCapturedValueEntry(params) {
     const buildMaskedCandidate = (limits) => {
         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, projected, params.capture.runtimeConfig, params.capture.maskReq, params.capture.trace, params.capture.masking, params.capture.privacy, params.capture.db);
@@ -4525,7 +4550,7 @@ function createCapturedValueEntry(params) {
         return { captureRef: { status: 'skipped-non-meaningful' } };
     }
     const candidateSerialized = stableSerializeTraceValue(candidate);
-    if (!candidateSerialized || candidateSerialized === previewSerialized) {
+    if (!candidateSerialized || (candidateSerialized === previewSerialized && !omissions.length)) {
         return undefined;
     }
     const valueId = contentAddressedValueId(params.target, candidateSerialized, params.capture);
@@ -4545,6 +4570,7 @@ function createCapturedValueEntry(params) {
             status: 'stored',
             valueId,
             projectedKind: entry.projectedKind,
+            ...(omissions.length ? { complete: false, omissions } : {}),
         },
         entry,
     };
@@ -4552,6 +4578,8 @@ function createCapturedValueEntry(params) {
 async function createCapturedValueEntryAsync(params) {
     if (!__FULL_VALUE_CAPTURE_ENABLED)
         return undefined;
+    const limitedRaw = constrainLiveCapture(params.rawValue, params.capture.runtimeConfig, params.target);
+    const omissions = isLiveCapture(params.capture.runtimeConfig) ? (0, live_capture_limits_1.collectCaptureOmissions)(limitedRaw) : [];
     const preferredLimits = {
         maxDepth: TRACE_FULL_VALUE_MAX_DEPTH,
         maxKeys: TRACE_FULL_VALUE_MAX_KEYS,
@@ -4561,7 +4589,7 @@ async function createCapturedValueEntryAsync(params) {
     const buildMaskedCandidate = async (limits) => {
         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, projected, params.capture.runtimeConfig, params.capture.maskReq, params.capture.trace, params.capture.masking, params.capture.privacy, params.capture.db);
@@ -4572,7 +4600,7 @@ async function createCapturedValueEntryAsync(params) {
         return { captureRef: { status: 'skipped-non-meaningful' } };
     }
     const candidateSerialized = stableSerializeTraceValue(candidate);
-    if (!candidateSerialized || candidateSerialized === previewSerialized) {
+    if (!candidateSerialized || (candidateSerialized === previewSerialized && !omissions.length)) {
         return undefined;
     }
     const valueId = contentAddressedValueId(params.target, candidateSerialized, params.capture);
@@ -4592,6 +4620,7 @@ async function createCapturedValueEntryAsync(params) {
             status: 'stored',
             valueId,
             projectedKind: entry.projectedKind,
+            ...(omissions.length ? { complete: false, omissions } : {}),
         },
         entry,
     };
@@ -4794,6 +4823,7 @@ function reproMiddleware(cfg) {
         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);
         }
@@ -4863,6 +4893,11 @@ function reproMiddleware(cfg) {
                     }],
             }, { priority: 'high' });
         }
+        const captureMode = backendLiveContext || req.headers['x-repro-capture-mode'] === 'live' || queryCaptureMode === 'live'
+            ? 'live' : 'staging';
+        const modeConfig = { ...captureCfg, captureMode };
+        shareRuntimePrivacyState(captureCfg, modeConfig);
+        captureCfg = modeConfig;
         const resolvePrivacy = () => getRuntimePrivacyState(captureCfg).policy ?? null;
         const clockSkewMs = headerTs !== null ? headerTs - requestStartRaw : 0;
         const rid = nextRequestId(requestEpochMs);
@@ -6287,6 +6322,8 @@ 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);
         }
@@ -6337,6 +6374,8 @@ function patchNodeHttpModuleRequest(mod) {
             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);
@@ -6513,6 +6552,11 @@ function cloneKafkaTelemetryValue(value) {
     }
 }
 async function materializeKafkaRequestBody(cfg, maskReq, body, captureScope) {
+    // 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), cfg, maskReq, null, normalizeMaskingConfig(cfg.masking), getRuntimePrivacyState(cfg).policy ?? null, undefined, captureScope);
 }
 function summarizeKafkaError(error) {
@@ -6557,7 +6601,8 @@ function resolveKafkaContext(cfg, headers) {
         readKafkaHeader(headers, KAFKA_HEADER_PARENT_SPAN_ID) ??
         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(traceId, fn) {
     const tracerWithTrace = __TRACER__?.withTrace;
@@ -6857,6 +6902,7 @@ function patchKafkaProducerInstance(producer, cfg) {
                         [KAFKA_HEADER_REQUEST_ID]: publishRid,
                         [KAFKA_HEADER_SESSION_ID]: sid,
                         [KAFKA_HEADER_ACTION_ID]: aid,
+                        'x-repro-capture-mode': ctx.captureScope?.liveCapture ? 'live' : 'staging',
                     }),
                 };
             });
@@ -6979,6 +7025,7 @@ function patchKafkaProducerInstance(producer, cfg) {
                                 [KAFKA_HEADER_REQUEST_ID]: publishRid,
                                 [KAFKA_HEADER_SESSION_ID]: sid,
                                 [KAFKA_HEADER_ACTION_ID]: aid,
+                                'x-repro-capture-mode': ctx.captureScope?.liveCapture ? 'live' : 'staging',
                             }),
                         };
                     }),
@@ -7091,6 +7138,7 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
         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 = [];
         const maskReq = {
@@ -7205,6 +7253,7 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
         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 = [];
         const maskReq = {
@@ -7642,7 +7691,8 @@ function resolveAmqpContext(cfg, headers) {
         readAmqpHeader(headers, KAFKA_HEADER_PARENT_SPAN_ID) ??
         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(traceId, fn) {
     const tracerWithTrace = __TRACER__?.withTrace;
@@ -7817,6 +7867,7 @@ function patchAmqplibPublishMethod(channel, cfg, methodName) {
             [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'
@@ -7922,6 +7973,7 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
         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 = [];
         const maskReq = {

package/dist/ingest/client.d.ts

@@ -3,8 +3,8 @@ export type EnqueueIngestOptions = {
     priority?: 'normal' | 'high' | 'critical';
 };
 export declare const configureIngestQueueDrain: (options: {
-    shouldDefer?: (() => boolean) | null;
-    deferMs?: number;
+    shouldDefer?: ((enqueuedAt?: number) => boolean) | null | undefined;
+    deferMs?: number | undefined;
 }) => void;
 export declare const kickIngestQueueDrain: () => void;
 export declare const postIngestEntries: (config: IngestClientConfig, sessionId: string, entries: LegacyEntry[]) => Promise<void>;

package/dist/ingest/client.js

@@ -47,6 +47,8 @@ let backoffMs = 0;
 let criticalBackoffMs = 0;
 let shouldDeferDrain = null;
 let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
+const throttledUntil = new Map();
+const throttleDelay = (config) => Math.max(0, (throttledUntil.get(resolveIngestUrl(config)) ?? 0) - Date.now());
 const configureIngestQueueDrain = (options) => {
     shouldDeferDrain = options.shouldDefer ?? null;
     if (Number.isFinite(options.deferMs) && Number(options.deferMs) >= 0) {
@@ -59,7 +61,7 @@ const kickIngestQueueDrain = () => {
         scheduleCriticalDrain();
     }
     if (ingestQueue.length > 0 && !drainTimer) {
-        scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+        scheduleDrain(shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt) ? deferDrainMs : 0);
     }
 };
 exports.kickIngestQueueDrain = kickIngestQueueDrain;
@@ -166,6 +168,9 @@ const postIngestEntries = async (config, sessionId, entries) => {
 };
 exports.postIngestEntries = postIngestEntries;
 const sendIngestEntries = async (config, sessionId, entries) => {
+    if (throttleDelay(config) > 0)
+        return 'throttled';
+    throttledUntil.delete(resolveIngestUrl(config));
     if (!sessionId || !Array.isArray(entries) || entries.length === 0) {
         return true;
     }
@@ -197,6 +202,18 @@ const sendIngestEntries = async (config, sessionId, entries) => {
             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(86400000, 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 {
@@ -216,12 +233,12 @@ const scheduleDrain = (delayMs = 0) => {
     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;
         }
@@ -257,7 +274,11 @@ const drainCriticalIngestQueue = async () => {
                 return;
             }
             const ok = await sendIngestEntries(selected.batch.config, 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;
@@ -281,14 +302,14 @@ const drainIngestQueue = async () => {
     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;
             }
@@ -298,7 +319,11 @@ const drainIngestQueue = async () => {
             }
             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;
@@ -342,6 +367,7 @@ const enqueueIngestEntries = (config, sessionId, entries, options = {}) => {
         sessionId,
         entries: entries.slice(),
         attempts: 0,
+        enqueuedAt: Date.now(),
         priority,
     };
     if (priority === 'critical') {

package/dist/live-capture-limits.d.ts

@@ -0,0 +1,19 @@
+export type CaptureOmission = {
+    reason: 'max-depth' | 'max-keys' | 'max-entries' | 'accessor' | 'uninspectable';
+    path: string;
+    limit?: number;
+    originalCount?: number;
+    capturedCount: number;
+};
+export declare const LIVE_CAPTURE_LIMITS: Readonly<{
+    maxDepth: 10;
+    maxKeys: 100;
+    maxEntries: 100;
+}>;
+/** Snapshot only data descriptors: capture must never execute application getters. */
+export declare function limitLiveCapture(value: unknown, rootPath?: string): {
+    value: any;
+    omissions: CaptureOmission[];
+};
+export declare function collectCaptureOmissions(value: any): CaptureOmission[];
+export declare function limitLiveArguments(args: any[]): any[];