@juspay/neurolink 12.12.6 → 12.12.8

package/dist/proxy/proxyActivity.js

@@ -8,6 +8,19 @@ let lastActivityAtMs = null;
 // response through one tracker, which fans these observers out at the point
 // where bytes actually leave the proxy.
 const responseObserversByMetadata = new WeakMap();
+const finalLogObservers = new Map();
+/** Join route accounting to the HTTP lifecycle without relying on write order. */
+export function observeProxyFinalLog(requestId, observer) {
+    finalLogObservers.set(requestId, observer);
+    return () => {
+        if (finalLogObservers.get(requestId) === observer) {
+            finalLogObservers.delete(requestId);
+        }
+    };
+}
+export function notifyProxyFinalLog(entry) {
+    finalLogObservers.get(entry.requestId)?.(entry);
+}
 export function registerProxyResponseObserver(metadata, observer) {
     const existing = responseObserversByMetadata.get(metadata);
     if (existing) {
@@ -69,12 +82,17 @@ export function isProxyActivityQuiet(snapshot, quietThresholdMs, nowMs = Date.no
 /** Keep activity open until the response body completes, errors, or is cancelled. */
 export function trackProxyResponse(response, finishRequest, observer) {
     if (!response.body) {
-        finishRequest();
-        safelyNotifyObserver(() => observer?.onTerminal?.({
-            outcome: "bodyless",
-            observedBodyBytes: 0,
-            responseChunks: 0,
-        }));
+        try {
+            const notified = observer?.onTerminal?.({
+                outcome: "bodyless",
+                observedBodyBytes: 0,
+                responseChunks: 0,
+            });
+            void Promise.resolve(notified).then(finishRequest, finishRequest);
+        }
+        catch {
+            finishRequest();
+        }
         return response;
     }
     const reader = response.body.getReader();
@@ -88,17 +106,25 @@ export function trackProxyResponse(response, finishRequest, observer) {
     void reader.closed.then(() => {
         sourceClosed = true;
     }, () => undefined);
-    const settle = (outcome) => {
+    const settle = (outcome, error) => {
         if (settled) {
             return;
         }
         settled = true;
-        finishRequest();
-        safelyNotifyObserver(() => observer?.onTerminal?.({
-            outcome,
-            observedBodyBytes,
-            responseChunks,
-        }));
+        // Keep drain accounting open through bounded terminal bookkeeping, but
+        // never hold back the client's response body while telemetry is written.
+        try {
+            const notified = observer?.onTerminal?.({
+                outcome,
+                error,
+                observedBodyBytes,
+                responseChunks,
+            });
+            void Promise.resolve(notified).then(finishRequest, finishRequest);
+        }
+        catch {
+            finishRequest();
+        }
     };
     const trackedBody = new ReadableStream({
         async pull(controller) {
@@ -120,7 +146,7 @@ export function trackProxyResponse(response, finishRequest, observer) {
                 }
             }
             catch (error) {
-                settle("stream_error");
+                settle("stream_error", error);
                 controller.error(error);
             }
         },

package/dist/proxy/proxyAnalysis.js

@@ -1,4 +1,5 @@
 import { createReadStream } from "node:fs";
+import { isDeepStrictEqual } from "node:util";
 import { lstat, readdir, realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
@@ -371,7 +372,9 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
     const errorTypes = {};
     const errorCodes = {};
     for (const [requestId, request] of finalRequests) {
-        const failed = request.status >= 400 || terminalStreamErrors.has(requestId);
+        const failed = request.status >= 400 ||
+            !!request.errorType ||
+            terminalStreamErrors.has(requestId);
         if (failed) {
             errors += 1;
         }
@@ -588,18 +591,25 @@ export async function analyzeProxyLogs(options) {
     const terminalOutcomes = {};
     const lifecycleErrorTypes = {};
     const lifecycleErrorCodes = {};
-    const headersLatency = [];
-    const firstChunkLatency = [];
-    const terminalLatency = [];
+    const headersLatencyByRequest = new Map();
+    const firstChunkLatencyByRequest = new Map();
+    const terminalLatencyByRequest = new Map();
     const sequences = new Map();
+    const seenLifecycleEvents = new Map();
+    let conflictingLifecycleDuplicates = 0;
+    const conflictedRequests = new Set();
+    const terminalRecords = new Map();
     for (const filePath of lifecycleFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("lifecycle", record);
-            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
+            const requestId = stringValue(record.requestId);
+            if (timestamp === null ||
+                !requestId ||
+                (!accepted.has(requestId) &&
+                    (timestamp < sinceMs || timestamp > untilMs))) {
                 return;
             }
             const event = stringValue(record.event);
-            const requestId = stringValue(record.requestId);
             if (record.schemaVersion !== 1 ||
                 !event ||
                 !LIFECYCLE_EVENTS.has(event) ||
@@ -613,27 +623,51 @@ export async function analyzeProxyLogs(options) {
                 const values = sequences.get(processId) ?? [];
                 values.push(sequence);
                 sequences.set(processId, values);
+                const identity = `${processId}:${sequence}`;
+                const previous = seenLifecycleEvents.get(identity);
+                if (previous) {
+                    if (!isDeepStrictEqual(previous, record)) {
+                        conflictingLifecycleDuplicates += 1;
+                        conflictedRequests.add(requestId);
+                        const previousRequestId = stringValue(previous.requestId);
+                        if (previousRequestId) {
+                            conflictedRequests.add(previousRequestId);
+                        }
+                    }
+                    return;
+                }
+                seenLifecycleEvents.set(identity, record);
             }
             const elapsed = finiteNumber(record.elapsedMs);
             if (event === "request_accepted") {
                 accepted.add(requestId);
             }
             else if (event === "response_headers") {
+                if (headers.has(requestId)) {
+                    return;
+                }
                 headers.add(requestId);
                 if (elapsed !== null && elapsed >= 0) {
-                    headersLatency.push(elapsed);
+                    headersLatencyByRequest.set(requestId, elapsed);
                 }
             }
             else if (event === "response_first_chunk") {
+                if (firstChunks.has(requestId)) {
+                    return;
+                }
                 firstChunks.add(requestId);
                 if (elapsed !== null && elapsed >= 0) {
-                    firstChunkLatency.push(elapsed);
+                    firstChunkLatencyByRequest.set(requestId, elapsed);
                 }
             }
             else {
+                if (terminal.has(requestId)) {
+                    return;
+                }
                 terminal.add(requestId);
+                terminalRecords.set(requestId, record);
                 if (elapsed !== null && elapsed >= 0) {
-                    terminalLatency.push(elapsed);
+                    terminalLatencyByRequest.set(requestId, elapsed);
                 }
                 increment(terminalOutcomes, stringValue(record.terminalOutcome) ?? "unknown");
                 const errorType = stringValue(record.errorType);
@@ -649,6 +683,14 @@ export async function analyzeProxyLogs(options) {
             malformedLines += 1;
         });
     }
+    // Contradictory copies are not reliable latency samples. Keep their data
+    // quality count, but do not choose one timing arbitrarily.
+    const verifiedLatencies = (values) => [...values]
+        .filter(([id]) => !conflictedRequests.has(id))
+        .map(([, ms]) => ms);
+    const headersLatency = verifiedLatencies(headersLatencyByRequest);
+    const firstChunkLatency = verifiedLatencies(firstChunkLatencyByRequest);
+    const terminalLatency = verifiedLatencies(terminalLatencyByRequest);
     let lifecycleSequenceGaps = 0;
     let lifecycleSequenceDuplicates = 0;
     for (const values of sequences.values()) {
@@ -675,70 +717,106 @@ export async function analyzeProxyLogs(options) {
     let transientRateLimits = 0;
     let quotaRateLimits = 0;
     let unclassifiedRateLimits = 0;
+    const uniqueAttempts = new Map();
+    let duplicateAttempts = 0;
     for (const filePath of attemptFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("attempts", record);
-            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
+            const requestId = stringValue(record.requestId);
+            const parentId = stringValue(record.parentRequestId) ??
+                requestId?.replace(/:codex-fallback$/, "");
+            if (timestamp === null ||
+                !requestId ||
+                (!accepted.has(parentId ?? requestId) &&
+                    (timestamp < sinceMs || timestamp > untilMs))) {
                 return;
             }
-            const requestId = stringValue(record.requestId);
             const status = finiteNumber(record.responseStatus);
-            const duration = finiteNumber(record.attemptDurationMs);
             if (!requestId || status === null) {
                 return;
             }
-            const account = stringValue(record.account) ?? "unknown";
-            const accountType = stringValue(record.accountType) ?? "unknown";
-            const accountStats = accountEntry(accounts, account, accountType);
-            totalAttempts += 1;
-            accountStats.attempts += 1;
-            const hadError = status >= 400 || !!stringValue(record.errorType);
-            if (hadError) {
-                totalAttemptErrors += 1;
-                accountStats.attemptErrors += 1;
-                increment(attemptErrorTypes, stringValue(record.errorType) ?? `http_${status}`);
-                const errorCode = stringValue(record.errorCode);
-                if (errorCode) {
-                    increment(attemptErrorCodes, errorCode);
-                }
-            }
-            const transportScope = stringValue(record.transportScope);
-            if (transportScope) {
-                increment(attemptTransportScopes, transportScope);
+            const identity = `${requestId}:${String(record.attempt ?? record.timestamp)}`;
+            const previous = uniqueAttempts.get(identity);
+            if (previous) {
+                duplicateAttempts += 1;
             }
-            const requestAttempts = attemptsByRequest.get(requestId) ?? {
-                count: 0,
-                hadError: false,
-                totalDurationMs: 0,
-                durationCount: 0,
-            };
-            requestAttempts.count += 1;
-            requestAttempts.hadError = requestAttempts.hadError || hadError;
-            if (duration !== null && duration >= 0) {
-                requestAttempts.totalDurationMs += duration;
-                requestAttempts.durationCount += 1;
-                attemptLatency.push(duration);
-            }
-            attemptsByRequest.set(requestId, requestAttempts);
-            if (status === 429) {
-                attemptRateLimits += 1;
-                if (record.rateLimitKind === "transient") {
-                    transientRateLimits += 1;
-                    accountStats.transientRateLimits += 1;
-                }
-                else if (record.rateLimitKind === "quota") {
-                    quotaRateLimits += 1;
-                    accountStats.quotaRateLimits += 1;
-                }
-                else {
-                    unclassifiedRateLimits += 1;
-                    accountStats.unclassifiedRateLimits += 1;
+            // A later terminal update enriches the same attempt, never creates a
+            // second upstream call. Preserve failure evidence across enrichment.
+            uniqueAttempts.set(identity, previous
+                ? {
+                    ...previous,
+                    ...record,
+                    ...((previous.errorType ||
+                        Number(previous.responseStatus) >= 400) &&
+                        !record.errorType &&
+                        status < 400
+                        ? {
+                            errorType: previous.errorType,
+                            responseStatus: previous.responseStatus,
+                            errorCode: previous.errorCode,
+                        }
+                        : {}),
                 }
-            }
+                : record);
         }, () => {
             malformedLines += 1;
         });
     }
+    for (const record of uniqueAttempts.values()) {
+        const rawRequestId = String(record.requestId);
+        const requestId = stringValue(record.parentRequestId) ??
+            rawRequestId.replace(/:codex-fallback$/, "");
+        const status = Number(record.responseStatus);
+        const duration = finiteNumber(record.attemptDurationMs);
+        const account = stringValue(record.account) ?? "unknown";
+        const accountType = stringValue(record.accountType) ?? "unknown";
+        const accountStats = accountEntry(accounts, account, accountType);
+        totalAttempts += 1;
+        accountStats.attempts += 1;
+        const hadError = status >= 400 || !!stringValue(record.errorType);
+        if (hadError) {
+            totalAttemptErrors += 1;
+            accountStats.attemptErrors += 1;
+            increment(attemptErrorTypes, stringValue(record.errorType) ?? `http_${status}`);
+            const errorCode = stringValue(record.errorCode);
+            if (errorCode) {
+                increment(attemptErrorCodes, errorCode);
+            }
+        }
+        const transportScope = stringValue(record.transportScope);
+        if (transportScope) {
+            increment(attemptTransportScopes, transportScope);
+        }
+        const requestAttempts = attemptsByRequest.get(requestId) ?? {
+            count: 0,
+            hadError: false,
+            totalDurationMs: 0,
+            durationCount: 0,
+        };
+        requestAttempts.count += 1;
+        requestAttempts.hadError = requestAttempts.hadError || hadError;
+        if (duration !== null && duration >= 0) {
+            requestAttempts.totalDurationMs += duration;
+            requestAttempts.durationCount += 1;
+            attemptLatency.push(duration);
+        }
+        attemptsByRequest.set(requestId, requestAttempts);
+        if (status === 429) {
+            attemptRateLimits += 1;
+            if (record.rateLimitKind === "transient") {
+                transientRateLimits += 1;
+                accountStats.transientRateLimits += 1;
+            }
+            else if (record.rateLimitKind === "quota") {
+                quotaRateLimits += 1;
+                accountStats.quotaRateLimits += 1;
+            }
+            else {
+                unclassifiedRateLimits += 1;
+                accountStats.unclassifiedRateLimits += 1;
+            }
+        }
+    }
     const finalRequests = new Map();
     const terminalStreamErrors = new Set();
     let validRoutingDecisions = 0;
@@ -763,7 +841,9 @@ export async function analyzeProxyLogs(options) {
             // but contributing nothing to tokens or cost, with nothing in the
             // report to say so. A request the window already admitted therefore
             // keeps accepting its own later records.
-            const alreadyAdmitted = finalRequests.has(requestId) || terminalStreamErrors.has(requestId);
+            const alreadyAdmitted = accepted.has(requestId) ||
+                finalRequests.has(requestId) ||
+                terminalStreamErrors.has(requestId);
             if (!alreadyAdmitted && (timestamp < sinceMs || timestamp > untilMs)) {
                 return;
             }
@@ -789,6 +869,7 @@ export async function analyzeProxyLogs(options) {
                 absentRoutingDecisions += 1;
             }
             const parsed = {
+                firstUsefulOutputMs: finiteNumber(record.firstUsefulOutputMs),
                 timestamp: new Date(timestamp).toISOString(),
                 status,
                 durationMs: finiteNumber(record.responseTimeMs),
@@ -814,6 +895,9 @@ export async function analyzeProxyLogs(options) {
                 ? {
                     ...previous,
                     ...Object.fromEntries(Object.entries(parsed).filter(([, value]) => value !== null && value !== undefined)),
+                    ...(previous.status >= 400 && status < 400
+                        ? { status: previous.status }
+                        : {}),
                     // Attribute the request to when it was first seen. A late
                     // completion record must not move it out of the window that
                     // admitted it.
@@ -824,6 +908,37 @@ export async function analyzeProxyLogs(options) {
             malformedLines += 1;
         });
     }
+    // Old lifecycle records described transport EOF as success even when the
+    // final request recorded a semantic failure. Reconcile, and expose every
+    // disagreement instead of letting a choice of input file change the answer.
+    let finalOutcomeConflicts = 0;
+    for (const key of Object.keys(terminalOutcomes)) {
+        delete terminalOutcomes[key];
+    }
+    for (const [requestId, record] of terminalRecords) {
+        const final = finalRequests.get(requestId);
+        const recorded = stringValue(record.terminalOutcome) ?? "unknown";
+        const resolved = final
+            ? final.status === 499 || final.errorType === "client_cancelled"
+                ? "client_cancelled"
+                : final.errorType?.includes("stream") ||
+                    terminalStreamErrors.has(requestId)
+                    ? "stream_error"
+                    : final.status >= 400 || final.errorType
+                        ? "handler_error"
+                        : "completed"
+            : conflictedRequests.has(requestId) ||
+                recorded === "completed" ||
+                recorded === "bodyless"
+                ? "unknown"
+                : recorded;
+        if (final &&
+            recorded !== resolved &&
+            !(recorded === "bodyless" && resolved === "completed")) {
+            finalOutcomeConflicts += 1;
+        }
+        increment(terminalOutcomes, resolved);
+    }
     let capturesIndexed = 0;
     let truncatedCaptures = 0;
     let writeFailures = 0;
@@ -920,6 +1035,13 @@ export async function analyzeProxyLogs(options) {
             unsupportedLifecycleLines,
             lifecycleSequenceGaps,
             lifecycleSequenceDuplicates,
+            conflictingLifecycleDuplicates,
+            duplicateAttempts,
+            finalOutcomeConflicts,
+            acceptedWithoutFinal: [...accepted].filter((id) => !finalRequests.has(id))
+                .length,
+            terminalWithoutFinal: [...terminal].filter((id) => !finalRequests.has(id))
+                .length,
             streams: Object.fromEntries(Object.entries(observedRanges).map(([stream, range]) => [
                 stream,
                 {
@@ -972,6 +1094,9 @@ export async function analyzeProxyLogs(options) {
         latencyMs: {
             headers: summarizeLatency(headersLatency),
             firstChunk: summarizeLatency(firstChunkLatency),
+            firstUsefulOutput: summarizeLatency([...finalRequests.values()].flatMap((record) => record.firstUsefulOutputMs === null
+                ? []
+                : [record.firstUsefulOutputMs])),
             terminal: summarizeLatency(terminalLatency),
             finalRequest: summarizeLatency(finalSummary.finalRequestLatency),
             attempt: summarizeLatency(attemptLatency),

package/dist/proxy/proxyLifecycle.d.ts

@@ -4,7 +4,7 @@ export declare function hashProxyLifecycleSessionId(sessionId: string | undefine
 export declare function configureProxyLifecycleLogger(options: ProxyLifecycleLoggerOptions): void;
 /** Enqueue fixed-size lifecycle metadata without awaiting filesystem work. */
 export declare function logProxyLifecycleEvent(input: ProxyLifecycleEventInput): void;
-export declare function flushProxyLifecycleEvents(): Promise<void>;
+export declare function flushProxyLifecycleEvents(timeoutMs?: number): Promise<void>;
 export declare function getProxyLifecycleLoggerSnapshot(): ProxyLifecycleLoggerSnapshot;
 export declare function resetProxyLifecycleLoggerForTests(): void;
 /** Isolated failure injection for lifecycle durability tests. */

package/dist/proxy/proxyLifecycle.js

@@ -32,6 +32,8 @@ let invalidDrops = 0;
 let writeDrops = 0;
 let writeFailures = 0;
 let writeRetries = 0;
+let writeTimeouts = 0;
+let unconfirmedWrites = 0;
 let inFlight = 0;
 let queue = [];
 let flushTimer;
@@ -157,15 +159,43 @@ async function flushBatch() {
         let retryDelayMs = 0;
         for (const [path, items] of byPath) {
             const lines = items.map((item) => `${JSON.stringify(item.record)}\n`);
+            // A timeout does not cancel appendFile. Keep ownership of the original
+            // operation until it settles; retrying it while it is still running can
+            // append the same batch twice. The request path remains non-blocking.
+            const timeout = setTimeout(() => {
+                writeTimeouts += 1;
+            }, LIFECYCLE_APPEND_TIMEOUT_MS);
+            timeout.unref?.();
             try {
                 // This best-effort telemetry sink intentionally avoids fsync so request
                 // throughput is not coupled to storage latency. Loss is surfaced by
                 // writeDrops/writeFailures rather than delaying proxy responses.
-                await withTimeout(appendLifecycleFile(path, lines.join(""), { mode: 0o600 }), LIFECYCLE_APPEND_TIMEOUT_MS, "Timed out writing proxy lifecycle metadata");
+                await appendLifecycleFile(path, lines.join(""), { mode: 0o600 });
                 written += lines.length;
             }
             catch (error) {
                 writeFailures += 1;
+                // These errors prevent opening the destination. Other failures (for
+                // example ENOSPC/EIO) can follow a partial append. Replaying those is
+                // unsafe; expose uncertainty instead of claiming either loss or success.
+                const code = error?.code;
+                const definitelyNotWritten = new Set([
+                    "ENOENT",
+                    "EACCES",
+                    "EPERM",
+                    "EROFS",
+                    "EMFILE",
+                    "ENFILE",
+                ]).has(code ?? "");
+                if (!definitelyNotWritten) {
+                    unconfirmedWrites += items.length;
+                    logger.warn("[proxy] lifecycle metadata append outcome is uncertain", {
+                        path,
+                        records: items.length,
+                        code,
+                    });
+                    continue;
+                }
                 const retryable = items.filter((item) => item.writeRetries < maxWriteRetries);
                 const exhausted = items.length - retryable.length;
                 if (retryable.length > 0) {
@@ -189,6 +219,9 @@ async function flushBatch() {
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
+            finally {
+                clearTimeout(timeout);
+            }
         }
         if (retries.length > 0) {
             // Keep retried records ahead of newly admitted records. This preserves
@@ -293,6 +326,16 @@ export function logProxyLifecycleEvent(input) {
             ...(sessionHash !== undefined ? { sessionHash } : {}),
             ...(requestBytes !== undefined ? { requestBytes } : {}),
             ...(responseStatus !== undefined ? { responseStatus } : {}),
+            ...(input.finalStatus !== undefined
+                ? { finalStatus: nonNegativeInteger(input.finalStatus) }
+                : {}),
+            ...(input.telemetryStatus
+                ? { telemetryStatus: input.telemetryStatus }
+                : {}),
+            ...(input.transportOutcome
+                ? { transportOutcome: input.transportOutcome }
+                : {}),
+            ...(input.outcomeSource ? { outcomeSource: input.outcomeSource } : {}),
             ...(observedBodyBytes !== undefined ? { observedBodyBytes } : {}),
             ...(responseChunks !== undefined ? { responseChunks } : {}),
             ...(elapsedMs !== undefined
@@ -316,16 +359,15 @@ export function logProxyLifecycleEvent(input) {
         invalidDrops += 1;
     }
 }
-export async function flushProxyLifecycleEvents() {
+export async function flushProxyLifecycleEvents(timeoutMs = 5_000) {
     clearScheduledFlush();
+    const deadline = performance.now() + timeoutMs;
     while (queue.length > 0 || flushInFlight) {
-        if (flushInFlight) {
-            await flushInFlight;
-        }
-        else {
-            await startFlush();
-        }
+        await withTimeout(flushInFlight ?? startFlush(), Math.max(1, deadline - performance.now()), "Timed out flushing proxy lifecycle metadata; writes remain pending");
         clearScheduledFlush();
+        if (performance.now() >= deadline && (queue.length > 0 || flushInFlight)) {
+            throw new Error("Proxy lifecycle flush deadline exceeded; writes remain pending");
+        }
     }
 }
 export function getProxyLifecycleLoggerSnapshot() {
@@ -343,6 +385,8 @@ export function getProxyLifecycleLoggerSnapshot() {
         writeDrops,
         writeFailures,
         writeRetries,
+        writeTimeouts,
+        unconfirmedWrites,
         pending: queue.length,
         inFlight,
         flushing: flushInFlight !== undefined,
@@ -368,6 +412,8 @@ export function resetProxyLifecycleLoggerForTests() {
     writeDrops = 0;
     writeFailures = 0;
     writeRetries = 0;
+    writeTimeouts = 0;
+    unconfirmedWrites = 0;
     inFlight = 0;
     queue = [];
     flushInFlight = undefined;

package/dist/proxy/requestLogger.d.ts

@@ -5,7 +5,8 @@
  * when a LoggerProvider is configured via OpenTelemetry instrumentation.
  * Useful for debugging and auditing proxy traffic.
  */
-import type { ProxyBodyCaptureEntry, RequestAttemptLogEntry, RequestLogEntry } from "../types/index.js";
+import type { ProxyBodyCaptureEntry, RequestAttemptLogEntry, RequestLogEntry, ProxyRequestLoggerSnapshot } from "../types/index.js";
+export declare function getRequestLoggerSnapshot(): ProxyRequestLoggerSnapshot;
 /** Wait, up to a bounded deadline, for admitted request/body writes to settle. */
 export declare function flushRequestLogs(timeoutMs?: number): Promise<void>;
 export declare function initRequestLogger(enabled?: boolean, customLogsDir?: string): void;