@juspay/neurolink 12.14.4 → 12.14.5

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. */