@juspay/neurolink 12.12.9 → 12.12.10

package/dist/proxy/bodyCaptureWorker.js

@@ -0,0 +1,232 @@
+import { Worker } from "node:worker_threads";
+const MAX_PENDING = 16;
+const MAX_PENDING_BYTES = 32 * 1024 * 1024;
+const MAX_ENTRY_BYTES = 8 * 1024 * 1024;
+export const PROXY_BODY_CAPTURE_DEADLINE_MS = 20_000;
+let worker;
+let workerUrl;
+let retryAfter = 0;
+let nextId = 0;
+const snapshot = {
+    attempted: 0,
+    completed: 0,
+    rejected: 0,
+    failed: 0,
+    pending: 0,
+    pendingBytes: 0,
+    maxPending: MAX_PENDING,
+    maxPendingBytes: MAX_PENDING_BYTES,
+};
+const pending = new Map();
+// Bound traversal as well as the structured clone sent to the worker. Never
+// invoke getters/toJSON or stringify a large body on the serving event loop.
+/**
+ * Conservatively bound clone size and traversal work without invoking
+ * getters or serializers.
+ */
+function estimateCloneBytes(value) {
+    const stack = [value];
+    const seen = new Set();
+    let bytes = 0, nodes = 0;
+    while (stack.length) {
+        if (++nodes > 100_000 || bytes > MAX_ENTRY_BYTES) {
+            return Infinity;
+        }
+        const item = stack.pop();
+        if (typeof item === "string") {
+            bytes += item.length * 3;
+            continue;
+        }
+        bytes += 16;
+        if (!item || typeof item !== "object") {
+            continue;
+        }
+        if (seen.has(item)) {
+            return Infinity;
+        }
+        seen.add(item);
+        if (!Array.isArray(item) &&
+            Object.getPrototypeOf(item) !== Object.prototype &&
+            Object.getPrototypeOf(item) !== null) {
+            return Infinity;
+        }
+        for (const key of Object.keys(item)) {
+            bytes += key.length * 3;
+            const descriptor = Object.getOwnPropertyDescriptor(item, key);
+            if (!descriptor || descriptor.get || descriptor.set) {
+                return Infinity;
+            }
+            stack.push(descriptor.value);
+            if (stack.length > 100_000 || bytes > MAX_ENTRY_BYTES) {
+                return Infinity;
+            }
+        }
+    }
+    return bytes;
+}
+/**
+ * Settle IPC ownership once while publication retains the capture memory
+ * lease.
+ */
+function settle(id, result) {
+    const task = pending.get(id);
+    if (!task) {
+        return;
+    }
+    pending.delete(id);
+    clearTimeout(task.timer);
+    task.resolve(result);
+    if (!pending.size) {
+        worker?.unref();
+    }
+}
+/**
+ * Fail every pending capture explicitly and back off without moving bulk
+ * work to the caller.
+ */
+function failWorker(current, reason) {
+    if (worker !== current) {
+        return;
+    }
+    worker = undefined;
+    retryAfter = Date.now() + 5_000;
+    for (const id of pending.keys()) {
+        settle(id, {
+            error: reason,
+            stored: { bodyWriteFailed: true },
+        });
+    }
+    void current.terminate().catch(() => undefined);
+}
+/**
+ * Lazily create the bounded worker; only admitted processing keeps it
+ * referenced.
+ */
+function getWorker() {
+    if (worker) {
+        return worker;
+    }
+    const current = new Worker(workerUrl ?? new URL("./bodyCaptureWorkerEntry.js", import.meta.url), {
+        execArgv: process.execArgv.filter((arg) => !arg.startsWith("--input-type")),
+        resourceLimits: { maxOldGenerationSizeMb: 128 },
+    });
+    worker = current;
+    current.on("message", (message) => {
+        if (worker === current) {
+            settle(message.id, message.result);
+        }
+    });
+    current.on("error", () => failWorker(current, "body_worker_error"));
+    current.on("exit", () => failWorker(current, "body_worker_exit"));
+    current.unref();
+    return current;
+}
+/** Bounded bulk capture. Failures are indexed; never fall back to blocking work. */
+export async function captureProxyBody(entry, logDir, consume) {
+    snapshot.attempted += 1;
+    let bytes;
+    try {
+        bytes = estimateCloneBytes(entry);
+    }
+    catch {
+        bytes = Infinity;
+    }
+    if (bytes > MAX_ENTRY_BYTES ||
+        snapshot.pending >= MAX_PENDING ||
+        snapshot.pendingBytes + bytes > MAX_PENDING_BYTES ||
+        Date.now() < retryAfter) {
+        snapshot.rejected += 1;
+        const error = bytes > MAX_ENTRY_BYTES
+            ? "body_capture_too_large_or_non_json"
+            : Date.now() < retryAfter
+                ? "body_worker_backoff"
+                : "body_capture_queue_full";
+        snapshot.lastError = error;
+        return consume({ error, stored: { bodyWriteFailed: true } });
+    }
+    let current;
+    try {
+        current = getWorker();
+    }
+    catch {
+        snapshot.failed += 1;
+        retryAfter = Date.now() + 5_000;
+        return consume({
+            error: "body_worker_start_failed",
+            stored: { bodyWriteFailed: true },
+        });
+    }
+    const id = ++nextId;
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => failWorker(current, "body_worker_timeout"), PROXY_BODY_CAPTURE_DEADLINE_MS);
+        timer.unref();
+        pending.set(id, {
+            timer,
+            resolve: (result) => {
+                // Keep the byte/count lease through index writes and OTLP publication,
+                // so completed worker results cannot form an unbounded parent backlog.
+                void consume(result)
+                    .catch(() => {
+                    result.error ??= "body_capture_publication_failed";
+                })
+                    .finally(() => {
+                    snapshot.pending -= 1;
+                    snapshot.pendingBytes -= bytes;
+                    if (result.error || result.stored.bodyWriteFailed) {
+                        snapshot.failed += 1;
+                    }
+                    else {
+                        snapshot.completed += 1;
+                    }
+                    if (result.error) {
+                        snapshot.lastError = result.error;
+                    }
+                    resolve();
+                });
+            },
+        });
+        snapshot.pending += 1;
+        snapshot.pendingBytes += bytes;
+        current.ref();
+        try {
+            current.postMessage({ id, entry, logDir, queuedAt: Date.now() });
+        }
+        catch {
+            settle(id, {
+                error: "body_capture_clone_failed",
+                stored: { bodyWriteFailed: true },
+            });
+        }
+    });
+}
+/**
+ * Return independent counters for processing, rejection, failure, and
+ * retained publication work.
+ */
+export function getBodyCaptureWorkerSnapshot() {
+    return { ...snapshot };
+}
+/** Isolated tests point at a separately executed built worker. */
+export const __bodyCaptureWorkerTestHooks = {
+    /**
+     * Reset an isolated worker after capture publications drain, optionally selecting a fixture entry.
+     */
+    async reset(url) {
+        if (worker) {
+            const current = worker;
+            failWorker(current, "body_worker_test_reset");
+            await current.terminate();
+        }
+        workerUrl = url;
+        retryAfter = 0;
+        Object.assign(snapshot, {
+            attempted: 0,
+            completed: 0,
+            rejected: 0,
+            failed: 0,
+            pending: 0,
+            pendingBytes: 0,
+            lastError: undefined,
+        });
+    },
+};

package/dist/proxy/bodyCaptureWorkerEntry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/proxy/bodyCaptureWorkerEntry.js

@@ -0,0 +1,34 @@
+import { parentPort } from "node:worker_threads";
+import { performance } from "node:perf_hooks";
+import { processProxyBodyCapture } from "./bodyCaptureProcessing.js";
+// Sequential processing bounds serialization/compression memory. The parent
+// bounds both the queued record count and clone bytes, including in-flight work.
+let tail = Promise.resolve();
+parentPort?.on("message", (message) => {
+    tail = tail.then(async () => {
+        const started = performance.now();
+        const queueWaitMs = Math.max(0, Date.now() - message.queuedAt);
+        try {
+            const result = await processProxyBodyCapture(message.entry, message.logDir);
+            parentPort?.postMessage({
+                id: message.id,
+                result: {
+                    ...result,
+                    queueWaitMs,
+                    processingMs: performance.now() - started,
+                },
+            });
+        }
+        catch {
+            parentPort?.postMessage({
+                id: message.id,
+                result: {
+                    error: "body_capture_processing_failed",
+                    stored: { bodyWriteFailed: true },
+                    queueWaitMs,
+                    processingMs: performance.now() - started,
+                },
+            });
+        }
+    });
+});

package/dist/proxy/proxyAnalysis.js

@@ -1,17 +1,20 @@
 import { createReadStream } from "node:fs";
 import { isDeepStrictEqual } from "node:util";
+import { isProxyAuxiliaryRequest } from "./proxyRequestKind.js";
 import { lstat, readdir, realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { ACCOUNT_COOLING_REASONS, PROXY_ACCOUNT_TYPES, PROXY_ACCOUNT_ROUTING_MODES, PROXY_ACCOUNT_ROUTING_REASONS, PROXY_ACCOUNT_ROUTING_STRATEGIES, } from "./routingEvidence.js";
 import { calculateCost, hasPricing, isExactPricingMatch, } from "../utils/pricing.js";
-const LIFECYCLE_FILE_PATTERN = /^proxy-lifecycle-\d{4}-\d{2}-\d{2}\.jsonl$/;
+const LIFECYCLE_FILE_PATTERN = /^proxy-(?:lifecycle|supervisor)-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const REQUEST_FILE_PATTERN = /^proxy-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const ATTEMPT_FILE_PATTERN = /^proxy-attempts-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const DEBUG_FILE_PATTERN = /^proxy-debug-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const ARTIFACT_STAT_CONCURRENCY = 64;
 const LIFECYCLE_EVENTS = new Set([
+    "runtime_sample",
+    "supervisor_event",
     "request_accepted",
     "response_headers",
     "response_first_chunk",
@@ -585,6 +588,7 @@ export async function analyzeProxyLogs(options) {
     let malformedLines = 0;
     let unsupportedLifecycleLines = 0;
     const accepted = new Set();
+    const auxiliaryRequests = new Set();
     const headers = new Set();
     const firstChunks = new Set();
     const terminal = new Set();
@@ -595,18 +599,36 @@ export async function analyzeProxyLogs(options) {
     const firstChunkLatencyByRequest = new Map();
     const terminalLatencyByRequest = new Map();
     const sequences = new Map();
+    const selectedSequenceRanges = new Map();
     const seenLifecycleEvents = new Map();
     let conflictingLifecycleDuplicates = 0;
     const conflictedRequests = new Set();
     const terminalRecords = new Map();
+    const acceptedWorkers = new Map();
+    const admittedWorkerIds = new Set();
+    const conflictedWorkerExits = new Set();
+    const conflictingIdentities = new Set();
+    const runtimeRecords = new Map();
+    const workerExits = new Map();
+    const runtime = {
+        samples: 0,
+        maxEventLoopDelayMs: null,
+        maxRssBytes: null,
+        maxCpuPercentOneCore: null,
+        maxHostLoad1m: null,
+    };
     for (const filePath of lifecycleFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
-            const timestamp = observeTimestamp("lifecycle", record);
+            const operational = record.event === "runtime_sample" ||
+                record.event === "supervisor_event";
+            const operationalTimestamp = Date.parse(String(record.timestamp));
+            const timestamp = operational
+                ? Number.isFinite(operationalTimestamp)
+                    ? operationalTimestamp
+                    : null
+                : observeTimestamp("lifecycle", record);
             const requestId = stringValue(record.requestId);
-            if (timestamp === null ||
-                !requestId ||
-                (!accepted.has(requestId) &&
-                    (timestamp < sinceMs || timestamp > untilMs))) {
+            if (timestamp === null || !requestId) {
                 return;
             }
             const event = stringValue(record.event);
@@ -614,7 +636,10 @@ export async function analyzeProxyLogs(options) {
                 !event ||
                 !LIFECYCLE_EVENTS.has(event) ||
                 !requestId) {
-                unsupportedLifecycleLines += 1;
+                if (accepted.has(requestId) ||
+                    (timestamp >= sinceMs && timestamp <= untilMs)) {
+                    unsupportedLifecycleLines += 1;
+                }
                 return;
             }
             const processId = stringValue(record.processInstanceId);
@@ -623,11 +648,40 @@ export async function analyzeProxyLogs(options) {
                 const values = sequences.get(processId) ?? [];
                 values.push(sequence);
                 sequences.set(processId, values);
+            }
+            const details = record.supervisorEvent && typeof record.supervisorEvent === "object"
+                ? record.supervisorEvent
+                : undefined;
+            const exitedWorkerId = stringValue(details?.workerProcessInstanceId);
+            const relatedExit = event === "supervisor_event" &&
+                details?.type === "worker_exit" &&
+                exitedWorkerId &&
+                admittedWorkerIds.has(exitedWorkerId);
+            // Audit intervening sequences before selecting the request cohort.
+            if (!accepted.has(requestId) &&
+                !relatedExit &&
+                (timestamp < sinceMs || timestamp > untilMs)) {
+                return;
+            }
+            if (processId && sequence !== null && Number.isInteger(sequence)) {
+                const range = selectedSequenceRanges.get(processId);
+                selectedSequenceRanges.set(processId, {
+                    min: Math.min(range?.min ?? sequence, sequence),
+                    max: Math.max(range?.max ?? sequence, sequence),
+                });
                 const identity = `${processId}:${sequence}`;
                 const previous = seenLifecycleEvents.get(identity);
                 if (previous) {
                     if (!isDeepStrictEqual(previous, record)) {
                         conflictingLifecycleDuplicates += 1;
+                        conflictingIdentities.add(identity);
+                        for (const copy of [previous, record]) {
+                            const detail = copy.supervisorEvent;
+                            const workerId = stringValue(detail?.workerProcessInstanceId);
+                            if (workerId) {
+                                conflictedWorkerExits.add(workerId);
+                            }
+                        }
                         conflictedRequests.add(requestId);
                         const previousRequestId = stringValue(previous.requestId);
                         if (previousRequestId) {
@@ -638,9 +692,36 @@ export async function analyzeProxyLogs(options) {
                 }
                 seenLifecycleEvents.set(identity, record);
             }
+            if (event === "runtime_sample") {
+                if (record.runtimeSample &&
+                    typeof record.runtimeSample === "object" &&
+                    processId &&
+                    sequence !== null) {
+                    runtimeRecords.set(`${processId}:${sequence}`, record.runtimeSample);
+                }
+                return;
+            }
+            if (event === "supervisor_event") {
+                if (details?.type === "worker_exit" && exitedWorkerId) {
+                    const exit = { ...details, at: record.timestamp };
+                    const previous = workerExits.get(exitedWorkerId);
+                    if (previous && !isDeepStrictEqual(previous, exit)) {
+                        conflictedWorkerExits.add(exitedWorkerId);
+                    }
+                    workerExits.set(exitedWorkerId, exit);
+                }
+                return;
+            }
+            if (isProxyAuxiliaryRequest(stringValue(record.method) ?? "", stringValue(record.path) ?? "")) {
+                auxiliaryRequests.add(requestId);
+            }
             const elapsed = finiteNumber(record.elapsedMs);
             if (event === "request_accepted") {
                 accepted.add(requestId);
+                if (processId) {
+                    acceptedWorkers.set(requestId, processId);
+                    admittedWorkerIds.add(processId);
+                }
             }
             else if (event === "response_headers") {
                 if (headers.has(requestId)) {
@@ -683,6 +764,25 @@ export async function analyzeProxyLogs(options) {
             malformedLines += 1;
         });
     }
+    for (const [identity, sample] of runtimeRecords) {
+        if (conflictingIdentities.has(identity)) {
+            continue;
+        }
+        runtime.samples += 1;
+        const mapping = {
+            maxEventLoopDelayMs: "eventLoopDelayMaxMs",
+            maxRssBytes: "rssBytes",
+            maxCpuPercentOneCore: "cpuPercentOneCore",
+            maxHostLoad1m: "hostLoad1m",
+        };
+        for (const [key, source] of Object.entries(mapping)) {
+            const value = finiteNumber(sample[source]);
+            if (value !== null && value >= 0) {
+                const target = key;
+                runtime[target] = Math.max(runtime[target] ?? value, value);
+            }
+        }
+    }
     // Contradictory copies are not reliable latency samples. Keep their data
     // quality count, but do not choose one timing arbitrarily.
     const verifiedLatencies = (values) => [...values]
@@ -693,7 +793,12 @@ export async function analyzeProxyLogs(options) {
     const terminalLatency = verifiedLatencies(terminalLatencyByRequest);
     let lifecycleSequenceGaps = 0;
     let lifecycleSequenceDuplicates = 0;
-    for (const values of sequences.values()) {
+    for (const [processId, allValues] of sequences) {
+        const range = selectedSequenceRanges.get(processId);
+        if (!range) {
+            continue;
+        }
+        const values = allValues.filter((value) => value >= range.min && value <= range.max);
         values.sort((a, b) => a - b);
         for (let index = 1; index < values.length; index += 1) {
             const difference = values[index] - values[index - 1];
@@ -918,6 +1023,9 @@ export async function analyzeProxyLogs(options) {
     for (const [requestId, record] of terminalRecords) {
         const final = finalRequests.get(requestId);
         const recorded = stringValue(record.terminalOutcome) ?? "unknown";
+        const auxiliaryTransport = auxiliaryRequests.has(requestId)
+            ? (stringValue(record.transportOutcome) ?? recorded)
+            : null;
         const resolved = final
             ? final.status === 499 || final.errorType === "client_cancelled"
                 ? "client_cancelled"
@@ -927,11 +1035,20 @@ export async function analyzeProxyLogs(options) {
                     : final.status >= 400 || final.errorType
                         ? "handler_error"
                         : "completed"
-            : conflictedRequests.has(requestId) ||
-                recorded === "completed" ||
-                recorded === "bodyless"
-                ? "unknown"
-                : recorded;
+            : auxiliaryTransport && !conflictedRequests.has(requestId)
+                ? auxiliaryTransport === "completed" ||
+                    auxiliaryTransport === "bodyless"
+                    ? finiteNumber(record.responseStatus) === null
+                        ? "unknown"
+                        : Number(record.responseStatus) >= 400
+                            ? "handler_error"
+                            : auxiliaryTransport
+                    : auxiliaryTransport
+                : conflictedRequests.has(requestId) ||
+                    recorded === "completed" ||
+                    recorded === "bodyless"
+                    ? "unknown"
+                    : recorded;
         if (final &&
             recorded !== resolved &&
             !(recorded === "bodyless" && resolved === "completed")) {
@@ -1038,10 +1155,8 @@ export async function analyzeProxyLogs(options) {
             conflictingLifecycleDuplicates,
             duplicateAttempts,
             finalOutcomeConflicts,
-            acceptedWithoutFinal: [...accepted].filter((id) => !finalRequests.has(id))
-                .length,
-            terminalWithoutFinal: [...terminal].filter((id) => !finalRequests.has(id))
-                .length,
+            acceptedWithoutFinal: [...accepted].filter((id) => !finalRequests.has(id) && !auxiliaryRequests.has(id)).length,
+            terminalWithoutFinal: [...terminal].filter((id) => !finalRequests.has(id) && !auxiliaryRequests.has(id)).length,
             streams: Object.fromEntries(Object.entries(observedRanges).map(([stream, range]) => [
                 stream,
                 {
@@ -1066,8 +1181,35 @@ export async function analyzeProxyLogs(options) {
                 absent: absentRoutingDecisions,
             },
         },
+        runtime,
         lifecycle: {
+            unconfirmedAtWorkerExit: [...accepted].flatMap((requestId) => {
+                const workerProcessInstanceId = acceptedWorkers.get(requestId);
+                const exit = workerProcessInstanceId
+                    ? workerExits.get(workerProcessInstanceId)
+                    : undefined;
+                if (!exit ||
+                    !workerProcessInstanceId ||
+                    conflictedWorkerExits.has(workerProcessInstanceId) ||
+                    terminal.has(requestId) ||
+                    conflictedRequests.has(requestId)) {
+                    return [];
+                }
+                return [
+                    {
+                        requestId,
+                        workerProcessInstanceId,
+                        at: String(exit.at),
+                        workerExitCode: finiteNumber(exit.workerExitCode),
+                        workerExitSignal: stringValue(exit.workerExitSignal),
+                        // A provider final cannot prove the client received the entire body.
+                        providerFinalRecorded: finalRequests.has(requestId),
+                    },
+                ];
+            }),
             accepted: accepted.size,
+            auxiliaryRequests: [...accepted].filter((id) => auxiliaryRequests.has(id))
+                .length,
             headers: headers.size,
             firstChunks: firstChunks.size,
             terminal: terminal.size,

package/dist/proxy/proxyLifecycle.d.ts

@@ -1,13 +1,38 @@
+import { chmodSync } from "node:fs";
 import { appendFile } from "node:fs/promises";
 import type { ProxyLifecycleEventInput, ProxyLifecycleLoggerOptions, ProxyLifecycleLoggerSnapshot } from "../types/index.js";
 export declare function hashProxyLifecycleSessionId(sessionId: string | undefined): string | undefined;
+/**
+ * Configure private journal storage while retaining required admission
+ * when initialization fails.
+ */
 export declare function configureProxyLifecycleLogger(options: ProxyLifecycleLoggerOptions): void;
 /** Enqueue fixed-size lifecycle metadata without awaiting filesystem work. */
 export declare function logProxyLifecycleEvent(input: ProxyLifecycleEventInput): void;
+/** Confirm admission before upstream dispatch, without waiting for later traffic.
+ * Disabled logging is explicit; an enabled but unhealthy sink refuses dispatch.
+ * A timeout never retries an ambiguous provider request or the pending append.
+ */
+export declare function persistProxyLifecycleAcceptance(input: Omit<ProxyLifecycleEventInput, "event">, timeoutMs?: number): Promise<void>;
 export declare function flushProxyLifecycleEvents(timeoutMs?: number): Promise<void>;
+/**
+ * Expose journal accounting, process identity, and outstanding writes
+ * without changing them.
+ */
 export declare function getProxyLifecycleLoggerSnapshot(): ProxyLifecycleLoggerSnapshot;
+/**
+ * Reset timers, accounting, and injected I/O after isolated tests have
+ * drained their work.
+ */
 export declare function resetProxyLifecycleLoggerForTests(): void;
 /** Isolated failure injection for lifecycle durability tests. */
 export declare const __proxyLifecycleTestHooks: {
+    /**
+     * Inject directory-hardening failures without altering real filesystem permissions.
+     */
+    setChmodForTests(chmod: typeof chmodSync): void;
+    /**
+     * Inject controlled append outcomes while preserving the production admission and queue paths.
+     */
     setAppendFileForTests(append: typeof appendFile): void;
 };