@juspay/neurolink 12.14.3 → 12.14.5

package/dist/proxy/otelLogSink.js

@@ -1,20 +1,40 @@
 /* eslint-disable no-console -- This proxy-only sink replaces console methods with OTLP emission. */
 import { inspect } from "node:util";
+import { setImmediate as yieldToRequests } from "node:timers/promises";
 import { SeverityNumber } from "@opentelemetry/api-logs";
 import { ExportResultCode } from "@opentelemetry/core";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
 import { sanitizeForLog } from "../utils/logSanitize.js";
+import { splitUtf8StringByBytes } from "./bodyCaptureProcessing.js";
 let provider;
 let restoreConsole;
 const queues = [];
+const bodyPublications = new Map();
+let bodyPublicationChain = Promise.resolve();
+let shuttingDown = false;
+const bodyDelivery = {
+    attempted: 0,
+    transportAcknowledged: 0,
+    exportUnconfirmed: 0,
+    rejected: 0,
+    partial: 0,
+    pending: 0,
+    pendingBytes: 0,
+    highWaterPending: 0,
+    highWaterBytes: 0,
+    maxPending: 16,
+    maxPendingBytes: 32 * 1024 * 1024,
+};
 /** Explicit opt-in; configuration never silently falls back to file logging. */
 export function isProxyOtelOnly() {
     return process.env.NEUROLINK_PROXY_LOG_SINK === "otel";
 }
 /** Reserve capacity including exports in flight, independently for metadata and bodies. */
-function createTrackedProcessor(url, capacity) {
+function createTrackedProcessor(url, capacity, kind) {
+    const unsettled = new Set();
+    const flushWaiters = new Set();
     const state = {
         attempted: 0,
         submitted: 0,
@@ -24,16 +44,23 @@ function createTrackedProcessor(url, capacity) {
         outstanding: 0,
         lastAcknowledgedAt: undefined,
         lastFailureAt: undefined,
+        highWaterOutstanding: 0,
     };
     const transport = new OTLPLogExporter({ url, timeoutMillis: 5000 });
     const exporter = {
         export(records, callback) {
             let settled = false;
+            const deadline = setTimeout(() => settle({
+                code: ExportResultCode.FAILED,
+                error: new Error("OTLP export callback deadline exceeded"),
+            }), 6_000);
+            deadline.unref();
             const settle = (result) => {
                 if (settled) {
                     return;
                 }
                 settled = true;
+                clearTimeout(deadline);
                 state.outstanding -= records.length;
                 if (result.code === ExportResultCode.SUCCESS) {
                     state.transportAcknowledged += records.length;
@@ -43,6 +70,23 @@ function createTrackedProcessor(url, capacity) {
                     state.exportUnconfirmed += records.length;
                     state.lastFailureAt = new Date().toISOString();
                 }
+                for (const record of records) {
+                    unsettled.delete(record);
+                    const id = record.attributes?.["body.capture_id"];
+                    const publication = typeof id === "string" ? bodyPublications.get(id) : undefined;
+                    if (publication) {
+                        if (result.code === ExportResultCode.SUCCESS) {
+                            publication.acknowledged++;
+                        }
+                        else {
+                            publication.unconfirmed++;
+                        }
+                        publication.notify?.();
+                    }
+                }
+                for (const notify of flushWaiters) {
+                    notify();
+                }
                 callback(result);
             };
             try {
@@ -66,18 +110,193 @@ function createTrackedProcessor(url, capacity) {
     const processor = {
         onEmit(record) {
             state.attempted++;
+            const id = record.attributes?.["body.capture_id"];
+            const publication = typeof id === "string" ? bodyPublications.get(id) : undefined;
+            if (publication) {
+                publication.emitted++;
+            }
             if (state.outstanding >= capacity) {
                 state.dropped++;
+                if (publication) {
+                    publication.dropped++;
+                    publication.notify?.();
+                }
                 return;
             }
             state.submitted++;
             state.outstanding++;
+            unsettled.add(record);
+            state.highWaterOutstanding = Math.max(state.highWaterOutstanding, state.outstanding);
             batch.onEmit(record);
         },
-        forceFlush: () => batch.forceFlush(),
-        shutdown: () => batch.shutdown(),
+        forceFlush: async () => {
+            const boundary = new Set(unsettled);
+            try {
+                await batch.forceFlush();
+            }
+            finally {
+                await new Promise((resolve) => {
+                    const check = () => {
+                        if (![...boundary].some((record) => unsettled.has(record))) {
+                            flushWaiters.delete(check);
+                            resolve();
+                        }
+                    };
+                    flushWaiters.add(check);
+                    check();
+                });
+            }
+        },
+        shutdown: async () => {
+            try {
+                await processor.forceFlush();
+            }
+            finally {
+                await batch.shutdown();
+            }
+        },
     };
-    return { state, processor, capacity };
+    return { state, processor, capacity, kind };
+}
+/**
+ * Own a whole capture within byte/count bounds, then pace its chunks by actual
+ * export callbacks. SDK forceFlush alone does not await an automatic export
+ * already in flight. Serial publication prevents bursts from dropping tails.
+ */
+export async function publishProxyOtelBody(captureId, body, emit) {
+    bodyDelivery.attempted++;
+    const bytes = Buffer.byteLength(body, "utf8");
+    if (!provider ||
+        shuttingDown ||
+        bodyPublications.has(captureId) ||
+        bodyDelivery.pending >= bodyDelivery.maxPending ||
+        bodyDelivery.pendingBytes + bytes > bodyDelivery.maxPendingBytes) {
+        bodyDelivery.rejected++;
+        return {
+            status: "rejected",
+            acknowledgedChunks: 0,
+            unconfirmedChunks: 0,
+            droppedChunks: 0,
+            reason: bodyPublications.has(captureId)
+                ? "body_capture_id_in_use"
+                : !provider || shuttingDown
+                    ? "body_exporter_unavailable"
+                    : "body_publication_queue_full",
+        };
+    }
+    bodyDelivery.pending++;
+    bodyDelivery.pendingBytes += bytes;
+    bodyDelivery.highWaterPending = Math.max(bodyDelivery.highWaterPending, bodyDelivery.pending);
+    bodyDelivery.highWaterBytes = Math.max(bodyDelivery.highWaterBytes, bodyDelivery.pendingBytes);
+    const progress = {
+        acknowledged: 0,
+        unconfirmed: 0,
+        dropped: 0,
+        emitted: 0,
+    };
+    bodyPublications.set(captureId, progress);
+    const deadline = Date.now() + 20_000;
+    const operation = bodyPublicationChain.then(async () => {
+        const queue = queues.find((candidate) => candidate.kind === "bodies");
+        if (!queue || Date.now() >= deadline) {
+            return {
+                status: "rejected",
+                acknowledgedChunks: 0,
+                unconfirmedChunks: 0,
+                droppedChunks: 0,
+                reason: !queue
+                    ? "body_exporter_unavailable"
+                    : "body_publication_deadline",
+            };
+        }
+        const chunks = splitUtf8StringByBytes(body, 16_000);
+        const awaitSettlement = () => new Promise((resolve) => {
+            const check = () => {
+                if (progress.acknowledged + progress.unconfirmed + progress.dropped >=
+                    progress.emitted) {
+                    progress.notify = undefined;
+                    resolve();
+                }
+            };
+            progress.notify = check;
+            check();
+        });
+        let reason;
+        try {
+            for (let offset = 0; offset < chunks.length; offset += 64) {
+                if (Date.now() >= deadline) {
+                    reason = "body_publication_deadline";
+                    break;
+                }
+                // Ordinary body records from an external logger may share this queue.
+                // Wait for them before admitting any part of this batch.
+                while (queue.state.outstanding > queue.capacity - 64) {
+                    await queue.processor.forceFlush();
+                    if (Date.now() >= deadline) {
+                        throw new Error("body_publication_deadline");
+                    }
+                }
+                for (let i = offset; i < Math.min(offset + 64, chunks.length); i++) {
+                    emit(chunks[i], i, chunks.length);
+                }
+                await queue.processor.forceFlush();
+                await awaitSettlement();
+                if (progress.unconfirmed || progress.dropped) {
+                    reason = "body_export_unconfirmed";
+                    break;
+                }
+                await yieldToRequests();
+            }
+        }
+        catch (error) {
+            reason =
+                error instanceof Error &&
+                    error.message === "body_publication_deadline"
+                    ? "body_publication_deadline"
+                    : "body_publication_failed";
+            // Retain ownership of already submitted chunks until their callbacks settle.
+            await queue.processor.forceFlush().catch(() => undefined);
+            await awaitSettlement();
+        }
+        const status = progress.emitted === 0 && chunks.length > 0
+            ? "rejected"
+            : progress.dropped || progress.emitted !== chunks.length
+                ? "partial"
+                : progress.unconfirmed
+                    ? "export_unconfirmed"
+                    : "transport_acknowledged";
+        return {
+            status,
+            expectedChunks: chunks.length,
+            acknowledgedChunks: progress.acknowledged,
+            unconfirmedChunks: progress.unconfirmed,
+            droppedChunks: progress.dropped,
+            notSubmittedChunks: chunks.length - progress.emitted,
+            ...(reason ? { reason } : {}),
+        };
+    });
+    bodyPublicationChain = operation.then(() => undefined, () => undefined);
+    try {
+        const result = await operation;
+        if (result.status === "transport_acknowledged") {
+            bodyDelivery.transportAcknowledged++;
+        }
+        else if (result.status === "export_unconfirmed") {
+            bodyDelivery.exportUnconfirmed++;
+        }
+        else if (result.status === "rejected") {
+            bodyDelivery.rejected++;
+        }
+        else {
+            bodyDelivery.partial++;
+        }
+        return result;
+    }
+    finally {
+        bodyPublications.delete(captureId);
+        bodyDelivery.pending--;
+        bodyDelivery.pendingBytes -= bytes;
+    }
 }
 /** Initialize a log-only provider in every proxy process, including the supervisor. */
 export function initializeProxyOtelLogs(role = "worker") {
@@ -102,8 +321,8 @@ export function initializeProxyOtelLogs(role = "worker") {
     if (url.protocol === "http:" && !loopback) {
         throw new Error("Proxy OTLP logs require HTTPS for non-loopback collectors");
     }
-    const metadata = createTrackedProcessor(endpoint, 2048);
-    const bodies = createTrackedProcessor(endpoint, 256);
+    const metadata = createTrackedProcessor(endpoint, 2048, "metadata");
+    const bodies = createTrackedProcessor(endpoint, 256, "bodies");
     queues.push(metadata, bodies);
     provider = new LoggerProvider({
         resource: resourceFromAttributes({
@@ -220,8 +439,9 @@ export function getProxyOtelLogSnapshot() {
         initialized: provider !== undefined,
         deliveryGuarantee: "best-effort; HTTP success is not per-record acceptance or backend persistence",
         invalidRecords,
-        queues: queues.map((q, index) => ({
-            kind: index === 0 ? "metadata" : "bodies",
+        bodyDelivery: { ...bodyDelivery },
+        queues: queues.map((q) => ({
+            kind: q.kind,
             capacity: q.capacity,
             ...q.state,
         })),
@@ -229,16 +449,35 @@ export function getProxyOtelLogSnapshot() {
 }
 /** Bounded provider flush belongs after final request and lifecycle publication. */
 export async function flushProxyOtelLogs() {
+    await bodyPublicationChain;
     await provider?.forceFlush();
 }
 /** Release this process's exporter and restore console ownership. */
 export async function shutdownProxyOtelLogs() {
+    shuttingDown = true;
+    await bodyPublicationChain;
     restoreConsole?.();
     restoreConsole = undefined;
     await provider?.shutdown();
     provider = undefined;
     queues.length = 0;
     invalidRecords = 0;
+    bodyPublications.clear();
+    bodyPublicationChain = Promise.resolve();
+    shuttingDown = false;
+    for (const key of [
+        "attempted",
+        "transportAcknowledged",
+        "exportUnconfirmed",
+        "rejected",
+        "partial",
+        "pending",
+        "pendingBytes",
+        "highWaterPending",
+        "highWaterBytes",
+    ]) {
+        bodyDelivery[key] = 0;
+    }
 }
 /** Flush short-lived proxy command diagnostics on every normal return or exception. */
 export function withProxyOtelLogShutdown(handler) {

package/dist/proxy/proxyActivity.d.ts

@@ -1,7 +1,9 @@
-import type { ProxyActivitySnapshot, ProxyResponseTrackingObserver, RequestLogEntry } from "../types/index.js";
+import type { ProxyActivitySnapshot, ProxyResponseTrackingObserver, RequestLogEntry, RequestAttemptLogEntry } from "../types/index.js";
 /** Join route accounting to the HTTP lifecycle without relying on write order. */
-export declare function observeProxyFinalLog(requestId: string, observer: (entry: RequestLogEntry) => void): () => void;
+export declare function observeProxyFinalLog(requestId: string, observer: (entry: RequestLogEntry) => void, attemptObserver?: (entry: RequestAttemptLogEntry) => void): () => void;
 export declare function notifyProxyFinalLog(entry: RequestLogEntry): void;
+/** Retain only the last attempt for a currently observed HTTP request. */
+export declare function notifyProxyAttemptLog(entry: RequestAttemptLogEntry): void;
 export declare function registerProxyResponseObserver(metadata: object, observer: ProxyResponseTrackingObserver): void;
 export declare function takeProxyResponseObservers(metadata: object): ProxyResponseTrackingObserver[];
 /** Track one client-facing proxy request until its response body settles. */

package/dist/proxy/proxyActivity.js

@@ -9,18 +9,37 @@ let lastActivityAtMs = null;
 // where bytes actually leave the proxy.
 const responseObserversByMetadata = new WeakMap();
 const finalLogObservers = new Map();
+const attemptLogObservers = new Map();
 /** Join route accounting to the HTTP lifecycle without relying on write order. */
-export function observeProxyFinalLog(requestId, observer) {
+export function observeProxyFinalLog(requestId, observer, attemptObserver) {
     finalLogObservers.set(requestId, observer);
+    if (attemptObserver) {
+        attemptLogObservers.set(requestId, attemptObserver);
+    }
+    else {
+        attemptLogObservers.delete(requestId);
+    }
     return () => {
         if (finalLogObservers.get(requestId) === observer) {
             finalLogObservers.delete(requestId);
+            attemptLogObservers.delete(requestId);
         }
     };
 }
 export function notifyProxyFinalLog(entry) {
     finalLogObservers.get(entry.requestId)?.(entry);
 }
+/** Retain only the last attempt for a currently observed HTTP request. */
+export function notifyProxyAttemptLog(entry) {
+    const observer = attemptLogObservers.get(entry.requestId);
+    observer?.(entry);
+    if (entry.parentRequestId && entry.parentRequestId !== entry.requestId) {
+        const parentObserver = attemptLogObservers.get(entry.parentRequestId);
+        if (parentObserver !== observer) {
+            parentObserver?.(entry);
+        }
+    }
+}
 export function registerProxyResponseObserver(metadata, observer) {
     const existing = responseObserversByMetadata.get(metadata);
     if (existing) {

package/dist/proxy/requestLogger.d.ts

@@ -33,6 +33,7 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     value?: string;
     bytes?: number;
     truncated: boolean;
+    originalBytes?: number;
 };
 /** Capture an owned request body with bounded processing and tracked index/export publication. */
 export declare function logBodyCapture(entry: ProxyBodyCaptureEntry): Promise<void>;

package/dist/proxy/requestLogger.js

@@ -5,7 +5,8 @@
  * when a LoggerProvider is configured via OpenTelemetry instrumentation.
  * Useful for debugging and auditing proxy traffic.
  */
-import { emitProxyOtelEvent, getProxyOtelLogSnapshot, initializeProxyOtelLogs, isProxyOtelOnly, } from "./otelLogSink.js";
+import { emitProxyOtelEvent, getProxyOtelLogSnapshot, initializeProxyOtelLogs, isProxyOtelOnly, publishProxyOtelBody, } from "./otelLogSink.js";
+import { randomUUID } from "node:crypto";
 import { join } from "path";
 import { homedir } from "os";
 import { logger } from "../utils/logger.js";
@@ -18,7 +19,7 @@ import { isBorrowedRequest } from "./shareContext.js";
 import { OtelBridge } from "../observability/otelBridge.js";
 import { SeverityNumber } from "@opentelemetry/api-logs";
 import { configureProxyLifecycleLogger } from "./proxyLifecycle.js";
-import { notifyProxyFinalLog } from "./proxyActivity.js";
+import { notifyProxyFinalLog, notifyProxyAttemptLog } from "./proxyActivity.js";
 import { withTimeout } from "../utils/async/withTimeout.js";
 let logDir = null;
 let logEnabled = false;
@@ -227,9 +228,6 @@ export async function logRequest(entry) {
  * or OTLP-derived dashboard panels.
  */
 export async function logRequestAttempt(entry) {
-    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
-        return;
-    }
     if (!entry.traceId) {
         const bridge = new OtelBridge();
         const traceCtx = bridge.getCurrentTraceContext();
@@ -238,6 +236,10 @@ export async function logRequestAttempt(entry) {
             entry.spanId = traceCtx.spanId;
         }
     }
+    notifyProxyAttemptLog(entry);
+    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
+        return;
+    }
     if (isProxyOtelOnly()) {
         emitProxyOtelEvent("attempt", entry);
         return;
@@ -445,16 +447,11 @@ function emitOtlpBodyLogRecord(entry, stored) {
     return resolveLoggerProvider()
         .then(async (provider) => {
         if (!provider || stored.redactedBody === undefined) {
-            return;
+            return undefined;
         }
         const otelLogger = provider.getLogger("neurolink-proxy-bodies", "1.0.0");
-        const chunks = splitUtf8StringByBytes(stored.redactedBody, BODY_OTLP_CHUNK_SIZE);
-        const totalChunks = Math.max(1, chunks.length);
-        for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
-            if (chunkIndex > 0 && chunkIndex % 4 === 0) {
-                await yieldToRequests();
-            }
-            const chunk = chunks[chunkIndex] ?? "";
+        const captureId = entry.captureId ?? randomUUID();
+        const emit = (chunk, chunkIndex, totalChunks) => {
             otelLogger.emit({
                 severityNumber: (entry.responseStatus ?? 0) >= 400
                     ? SeverityNumber.WARN
@@ -466,6 +463,7 @@ function emitOtlpBodyLogRecord(entry, stored) {
                     "proxy.record_kind": "body",
                     "request.id": entry.requestId,
                     "body.phase": entry.phase,
+                    "body.capture_id": captureId,
                     "body.chunk_index": chunkIndex,
                     "body.chunk_count": totalChunks,
                     "body.content_type": entry.contentType ?? "application/json",
@@ -500,10 +498,22 @@ function emitOtlpBodyLogRecord(entry, stored) {
                     source: "otlp",
                 },
             });
+        };
+        if (isProxyOtelOnly()) {
+            return publishProxyOtelBody(captureId, stored.redactedBody, emit);
         }
+        const chunks = splitUtf8StringByBytes(stored.redactedBody, BODY_OTLP_CHUNK_SIZE);
+        for (let i = 0; i < chunks.length; i++) {
+            if (i > 0 && i % 4 === 0) {
+                await yieldToRequests();
+            }
+            emit(chunks[i], i, chunks.length);
+        }
+        return undefined;
     })
         .catch(() => {
         // Non-fatal — never crash proxy for OTLP log failures
+        return undefined;
     });
 }
 /** Capture an owned request body with bounded processing and tracked index/export publication. */
@@ -525,7 +535,11 @@ export async function logBodyCapture(entry) {
     const destination = logDir;
     // Publication callbacks retain metadata and the bounded redacted result,
     // never the original unbounded body while a sink is slow.
-    const metadata = { ...entry, body: undefined };
+    const metadata = {
+        ...entry,
+        captureId: entry.captureId ?? randomUUID(),
+        body: undefined,
+    };
     /** Persist the processed capture index and publish its redacted body before releasing capacity. */
     const consume = async (processed) => {
         const redactedHeaders = processed.headers;
@@ -538,6 +552,7 @@ export async function logBodyCapture(entry) {
             timestamp: metadata.timestamp,
             type: "body_capture",
             requestId: metadata.requestId,
+            captureId: metadata.captureId,
             phase: metadata.phase,
             model: metadata.model,
             stream: metadata.stream,
@@ -554,6 +569,8 @@ export async function logBodyCapture(entry) {
             redactedBodyBytes: stored.redactedBodyBytes,
             storedFileBytes: stored.storedFileBytes,
             bodyTruncated: stored.bodyTruncated,
+            bodyCaptureLimitBytes: stored.bodyCaptureLimitBytes,
+            originalRedactedBodyBytes: stored.originalRedactedBodyBytes,
             bodyWriteFailed: stored.bodyWriteFailed,
             captureError: processed.error,
             captureQueueWaitMs: processed.queueWaitMs,
@@ -565,7 +582,21 @@ export async function logBodyCapture(entry) {
             indexEntry.spanId = traceCtx.spanId;
         }
         if (isProxyOtelOnly()) {
+            const delivery = await emitOtlpBodyLogRecord({
+                ...metadata,
+                traceId: traceCtx?.traceId ?? metadata.traceId,
+                spanId: traceCtx?.spanId ?? metadata.spanId,
+            }, stored);
+            indexEntry.bodyDelivery = delivery ?? {
+                status: processed.error
+                    ? "capture_rejected"
+                    : stored.redactedBody === undefined
+                        ? "no_body"
+                        : "export_unconfirmed",
+                ...(processed.error ? { reason: processed.error } : {}),
+            };
             emitProxyOtelEvent("body_capture_index", indexEntry);
+            return;
         }
         try {
             if (logFile) {
@@ -583,7 +614,14 @@ export async function logBodyCapture(entry) {
             spanId: traceCtx?.spanId ?? metadata.spanId,
         }, stored);
     };
-    return trackLogOperation(captureProxyBody(entry, destination, consume));
+    const operation = trackLogOperation(captureProxyBody(entry, destination, consume));
+    // HTTP handlers may await this function. Collector latency must never hold
+    // their response open; shutdown uses flushRequestLogs as the completion fence.
+    if (isProxyOtelOnly()) {
+        void operation;
+        return;
+    }
+    return operation;
 }
 /**
  * Log the FULL raw request and response for debugging.

package/dist/types/proxy.d.ts

@@ -641,8 +641,31 @@ export type ProxyBodyCaptureWorkerSnapshot = {
     pendingBytes: number;
     maxPending: number;
     maxPendingBytes: number;
+    /** Admission failures by exact guard, independent of processing failures. */
+    rejectionReasons: Record<string, number>;
     lastError?: string;
 };
+/** Collector transport evidence; acknowledgement does not prove backend storage. */
+export type ProxyBodyDeliveryResult = {
+    status: "transport_acknowledged" | "export_unconfirmed" | "rejected" | "partial";
+    /** Absent when publication was rejected before chunking. */
+    expectedChunks?: number;
+    acknowledgedChunks: number;
+    unconfirmedChunks: number;
+    droppedChunks: number;
+    notSubmittedChunks?: number;
+    reason?: string;
+};
+/** One bounded body publication, tracked across exporter callbacks. */
+export type ProxyBodyPublicationProgress = {
+    acknowledged: number;
+    unconfirmed: number;
+    dropped: number;
+    emitted: number;
+    notify?: () => void;
+};
+/** Chunk emission stays in the request logger, which owns request attributes. */
+export type ProxyBodyChunkEmitter = (chunk: string, index: number, count: number) => void;
 export type ProxyRequestLoggerSnapshot = {
     diskEnabled?: boolean;
     otel?: ReturnType<typeof import("../proxy/otelLogSink.js").getProxyOtelLogSnapshot>;
@@ -1991,6 +2014,8 @@ export type ProxyAnalysisRoutingRecord = {
 };
 /** Request metadata retained by the HTTP adapter for terminal error logging. */
 export type RuntimeRequestMetadata = {
+    /** Last dispatched attempt, retained until this HTTP request terminates. */
+    lastUpstreamAttempt?: RequestAttemptLogEntry;
     requestId: string;
     method: string;
     path: string;
@@ -2022,6 +2047,8 @@ export type RawStreamCaptureResult = {
 };
 /** Single captured body/headers entry written to disk by the proxy logger. */
 export type ProxyBodyCaptureEntry = {
+    /** Unique capture identity shared by its index and every exported chunk. */
+    captureId?: string;
     timestamp: string;
     requestId: string;
     phase: string;
@@ -2169,6 +2196,8 @@ export type StoredBodyArtifact = {
     storedFileBytes?: number;
     redactedBody?: string;
     bodyTruncated?: boolean;
+    bodyCaptureLimitBytes?: number;
+    originalRedactedBodyBytes?: number;
     bodyWriteFailed?: boolean;
 };
 /** File the proxy logger tracks for rotation and cleanup. */