@juspay/neurolink 12.12.6 → 12.12.7

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;

package/dist/proxy/requestLogger.js

@@ -17,11 +17,78 @@ 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 { withTimeout } from "../utils/async/withTimeout.js";
 let logDir = null;
 let logEnabled = false;
 const pendingLogOperations = new Set();
 const REQUEST_LOG_IO_TIMEOUT_MS = 5_000;
+const MAX_PENDING_METADATA_RECORDS = 4_096;
+const appendChains = new Map();
+let appendMetadataFile = writeFile;
+const createSinkSnapshot = () => ({
+    attempted: 0,
+    written: 0,
+    inFlight: 0,
+    pending: 0,
+    dropped: 0,
+    writeTimeouts: 0,
+    unconfirmedWrites: 0,
+});
+const metadataSinks = {
+    requests: createSinkSnapshot(),
+    attempts: createSinkSnapshot(),
+    debug: createSinkSnapshot(),
+};
+export function getRequestLoggerSnapshot() {
+    return {
+        enabled: logEnabled,
+        requests: { ...metadataSinks.requests },
+        attempts: { ...metadataSinks.attempts },
+        debug: { ...metadataSinks.debug },
+    };
+}
+async function appendMetadataRecord(file, line, kind) {
+    const sink = metadataSinks[kind];
+    sink.attempted += 1;
+    if (sink.pending + sink.inFlight >= MAX_PENDING_METADATA_RECORDS) {
+        sink.dropped += 1;
+        return;
+    }
+    sink.pending += 1;
+    // writeFile may perform multiple append syscalls for a large record. Order
+    // them per destination so concurrent records cannot interleave in this worker.
+    const operation = trackLogOperation((appendChains.get(file) ?? Promise.resolve()).then(async () => {
+        sink.pending -= 1;
+        sink.inFlight += 1;
+        const timer = setTimeout(() => {
+            sink.writeTimeouts += 1;
+        }, REQUEST_LOG_IO_TIMEOUT_MS);
+        timer.unref?.();
+        try {
+            await appendMetadataFile(file, line, { mode: 0o600, flag: "a" });
+            sink.written += 1;
+        }
+        catch (error) {
+            // A failed append may have written a prefix; never replay it.
+            sink.unconfirmedWrites += 1;
+            sink.lastErrorCode =
+                error?.code ?? "UNKNOWN";
+        }
+        finally {
+            clearTimeout(timer);
+            sink.inFlight -= 1;
+        }
+    }));
+    appendChains.set(file, operation);
+    void operation.then(() => {
+        if (appendChains.get(file) === operation) {
+            appendChains.delete(file);
+        }
+    });
+    // Bound the caller's wait, not the lifetime/ownership of the underlying write.
+    await withTimeout(operation, REQUEST_LOG_IO_TIMEOUT_MS, "Proxy metadata write remains pending").catch(() => undefined);
+}
 function trackLogOperation(operation) {
     pendingLogOperations.add(operation);
     void operation.then(() => pendingLogOperations.delete(operation), () => pendingLogOperations.delete(operation));
@@ -33,15 +100,7 @@ export async function flushRequestLogs(timeoutMs = REQUEST_LOG_IO_TIMEOUT_MS) {
     while (pendingLogOperations.size > 0) {
         const admitted = [...pendingLogOperations];
         const remainingMs = Math.max(1, deadline - Date.now());
-        try {
-            await withTimeout(Promise.allSettled(admitted), remainingMs, `Timed out flushing ${admitted.length} proxy request log operation(s)`);
-        }
-        catch (error) {
-            for (const operation of admitted) {
-                pendingLogOperations.delete(operation);
-            }
-            throw error;
-        }
+        await withTimeout(Promise.allSettled(admitted), remainingMs, `Timed out flushing ${admitted.length} proxy request log operation(s)`);
         if (Date.now() >= deadline && pendingLogOperations.size > 0) {
             const remaining = pendingLogOperations.size;
             throw new Error(`Timed out flushing ${remaining} proxy request log operation(s)`);
@@ -52,6 +111,12 @@ export async function flushRequestLogs(timeoutMs = REQUEST_LOG_IO_TIMEOUT_MS) {
 export const __requestLoggerTestHooks = {
     pendingOperationCount: () => pendingLogOperations.size,
     trackLogOperation,
+    setAppendFileForTests: (writer) => {
+        appendMetadataFile = writer;
+    },
+    restoreAppendFileForTests: () => {
+        appendMetadataFile = writeFile;
+    },
 };
 /**
  * Lazily-resolved LoggerProvider from OTel instrumentation.
@@ -104,6 +169,15 @@ export function initRequestLogger(enabled = true, customLogsDir) {
     }
 }
 export async function logRequest(entry) {
+    entry.terminalOutcome ??=
+        entry.errorType === "client_cancelled" || entry.responseStatus === 499
+            ? "client_cancelled"
+            : entry.errorType?.includes("stream")
+                ? "stream_error"
+                : entry.responseStatus >= 400 || entry.errorType
+                    ? "handler_error"
+                    : "completed";
+    notifyProxyFinalLog(entry);
     if (!logEnabled || !logDir) {
         return;
     }
@@ -121,11 +195,7 @@ export async function logRequest(entry) {
     const logFile = join(logDir, `proxy-${new Date().toISOString().split("T")[0]}.jsonl`);
     const line = JSON.stringify(entry) + "\n";
     try {
-        await trackLogOperation(writeFile(logFile, line, {
-            mode: 0o600,
-            flag: "a",
-            signal: AbortSignal.timeout(REQUEST_LOG_IO_TIMEOUT_MS),
-        }));
+        await appendMetadataRecord(logFile, line, "requests");
     }
     catch {
         // Non-fatal — don't crash proxy for logging failures
@@ -153,11 +223,7 @@ export async function logRequestAttempt(entry) {
     const logFile = join(logDir, `proxy-attempts-${new Date().toISOString().split("T")[0]}.jsonl`);
     const line = JSON.stringify(entry) + "\n";
     try {
-        await trackLogOperation(writeFile(logFile, line, {
-            mode: 0o600,
-            flag: "a",
-            signal: AbortSignal.timeout(REQUEST_LOG_IO_TIMEOUT_MS),
-        }));
+        await appendMetadataRecord(logFile, line, "attempts");
     }
     catch {
         // Non-fatal — don't crash proxy for logging failures
@@ -615,11 +681,7 @@ export async function logBodyCapture(entry) {
         indexEntry.spanId = traceCtx.spanId;
     }
     try {
-        await trackLogOperation(writeFile(logFile, JSON.stringify(indexEntry) + "\n", {
-            mode: 0o600,
-            flag: "a",
-            signal: AbortSignal.timeout(REQUEST_LOG_IO_TIMEOUT_MS),
-        }));
+        await appendMetadataRecord(logFile, JSON.stringify(indexEntry) + "\n", "debug");
     }
     catch {
         // Non-fatal
@@ -691,11 +753,7 @@ export async function logStreamError(entry) {
         logEntry.spanId = traceCtx.spanId;
     }
     try {
-        await trackLogOperation(writeFile(logFile, JSON.stringify(logEntry) + "\n", {
-            mode: 0o600,
-            flag: "a",
-            signal: AbortSignal.timeout(REQUEST_LOG_IO_TIMEOUT_MS),
-        }));
+        await appendMetadataRecord(logFile, JSON.stringify(logEntry) + "\n", "requests");
     }
     catch {
         // Non-fatal — don't crash proxy for logging failures