@juspay/neurolink 9.41.0 → 9.42.1

package/dist/lib/proxy/rawStreamCapture.js

@@ -0,0 +1,83 @@
+/** Maximum bytes to capture before stopping accumulation (1 MB). */
+const MAX_CAPTURE_BYTES = 1024 * 1024;
+const TRUNCATION_MARKER = "\n...[TRUNCATED]";
+export function createRawStreamCapture() {
+    const decoder = new TextDecoder();
+    const chunks = [];
+    let totalBytes = 0;
+    let capturedBytes = 0;
+    let truncated = false;
+    let resolved = false;
+    let resolveCapture;
+    const capture = new Promise((resolve) => {
+        resolveCapture = resolve;
+    });
+    function settle() {
+        if (resolved) {
+            return;
+        }
+        resolved = true;
+        const finalChunk = decoder.decode();
+        if (finalChunk) {
+            if (capturedBytes < MAX_CAPTURE_BYTES) {
+                const remainingBytes = MAX_CAPTURE_BYTES - capturedBytes;
+                chunks.push(finalChunk.slice(0, remainingBytes));
+                capturedBytes += Math.min(finalChunk.length, remainingBytes);
+            }
+            else if (!truncated) {
+                chunks.push(TRUNCATION_MARKER);
+                truncated = true;
+            }
+        }
+        resolveCapture({
+            totalBytes,
+            text: chunks.join(""),
+            truncated,
+        });
+    }
+    const transform = new TransformStream({
+        transform(chunk, controller) {
+            controller.enqueue(chunk);
+            totalBytes += chunk.byteLength;
+            if (capturedBytes < MAX_CAPTURE_BYTES) {
+                const decoded = decoder.decode(chunk, { stream: true });
+                const remainingBytes = MAX_CAPTURE_BYTES - capturedBytes;
+                const slice = decoded.slice(0, remainingBytes);
+                chunks.push(slice);
+                capturedBytes += Math.min(decoded.length, remainingBytes);
+                if (decoded.length > remainingBytes && !truncated) {
+                    chunks.push(TRUNCATION_MARKER);
+                    truncated = true;
+                }
+            }
+            else if (!truncated) {
+                chunks.push(TRUNCATION_MARKER);
+                truncated = true;
+            }
+        },
+        flush() {
+            settle();
+        },
+    });
+    const innerWriter = transform.writable.getWriter();
+    const writable = new WritableStream({
+        write(chunk) {
+            return innerWriter.write(chunk);
+        },
+        close() {
+            return innerWriter.close();
+        },
+        abort(reason) {
+            settle();
+            return innerWriter.abort(reason);
+        },
+    });
+    return {
+        stream: {
+            readable: transform.readable,
+            writable,
+        },
+        capture,
+    };
+}
+//# sourceMappingURL=rawStreamCapture.js.map

package/dist/lib/proxy/requestLogger.d.ts

@@ -1,18 +1,44 @@
 /**
  * Proxy Request Logger
  * Logs proxy request/response metadata to a rotating log file.
+ * Also emits OTLP log records to OpenObserve (or any OTLP-compatible backend)
+ * when a LoggerProvider is configured via OpenTelemetry instrumentation.
  * Useful for debugging and auditing proxy traffic.
  */
-import type { RequestLogEntry } from "../types/index.js";
+import type { RequestAttemptLogEntry, RequestLogEntry } from "../types/index.js";
 export declare function initRequestLogger(enabled?: boolean): void;
 export declare function logRequest(entry: RequestLogEntry): Promise<void>;
+/**
+ * Log an upstream attempt separately from the final request outcome.
+ * Attempt logs are local-only and must not pollute the final request summary
+ * or OTLP-derived dashboard panels.
+ */
+export declare function logRequestAttempt(entry: RequestAttemptLogEntry): Promise<void>;
 export declare function getLogDir(): string | null;
+type ProxyBodyCaptureEntry = {
+    timestamp: string;
+    requestId: string;
+    phase: string;
+    model: string;
+    stream: boolean;
+    headers?: Record<string, string>;
+    body?: unknown;
+    bodySize?: number;
+    contentType?: string;
+    responseStatus?: number;
+    durationMs?: number;
+    account?: string;
+    accountType?: string;
+    attempt?: number;
+    traceId?: string;
+    spanId?: string;
+    metadata?: Record<string, unknown>;
+};
+export declare function logBodyCapture(entry: ProxyBodyCaptureEntry): Promise<void>;
 /**
  * Log the FULL raw request and response for debugging.
- * Writes to a separate file: proxy-debug-YYYY-MM-DD.jsonl
- * Each entry has the complete request body and response body.
- *
- * Sensitive headers and body fields are redacted before writing.
+ * Legacy helper kept for compatibility. New call sites should prefer
+ * logBodyCapture() so each phase can be indexed and persisted separately.
  */
 export declare function logFullRequestResponse(entry: {
     timestamp: string;
@@ -48,3 +74,4 @@ export declare function logStreamError(entry: {
  * Non-fatal — proxy keeps working even if cleanup fails.
  */
 export declare function cleanupLogs(maxAgeDays?: number, maxSizeMb?: number): void;
+export {};