@juspay/neurolink 12.14.4 → 12.14.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.14.4",
+  "version": "12.14.6",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -147,6 +147,7 @@
     "test:proxy": "pnpm exec tsx test/continuous-test-suite-proxy.ts",
     "test:proxy-connect-retry": "pnpm exec tsx test/continuous-test-suite-proxy-connect-retry.ts",
     "test:proxy-telemetry": "pnpm exec tsx test/continuous-test-suite-proxy-telemetry.ts",
+    "test:proxy-restart": "pnpm exec tsx test/continuous-test-suite-proxy-restart.ts",
     "test:codex": "pnpm exec tsx test/continuous-test-suite-codex.ts",
     "test:bugfixes": "pnpm exec tsx test/continuous-test-suite-bugfixes.ts",
     "test:json-e2e": "pnpm exec tsx test/continuous-test-suite-json-e2e.ts",

package/scripts/observability/check-proxy-telemetry.mjs

@@ -13,12 +13,12 @@ const DEFAULT_MAX_LAG_SECONDS = 900;
 const STREAMS_TO_CHECK = [
   {
     type: "logs",
-    name: "neurolink_proxy",
+    name: process.env.NEUROLINK_PROXY_STREAM_HEADER || "neurolink_proxy",
     label: "OpenObserve logs",
   },
   {
     type: "traces",
-    name: "neurolink_proxy",
+    name: process.env.NEUROLINK_PROXY_STREAM_HEADER || "neurolink_proxy",
     label: "OpenObserve traces",
   },
   {
@@ -74,6 +74,7 @@ async function fetchStreams(type) {
   );
 
   const response = await fetch(url, {
+    signal: globalThis.AbortSignal.timeout(15_000),
     headers: {
       Authorization: getAuthHeader(),
     },
@@ -156,7 +157,8 @@ async function main() {
     ),
   );
 
-  const localSummary = await readLatestLocalSummary();
+  const otelOnly = process.env.NEUROLINK_PROXY_LOG_SINK === "otel";
+  const localSummary = otelOnly ? null : await readLatestLocalSummary();
   const localSummaryMicros = localSummary?.timestamp
     ? new Date(localSummary.timestamp).getTime() * 1000
     : null;
@@ -186,18 +188,27 @@ async function main() {
 
     console.log(`${stream.label}: ${status}`);
     console.log(`  stream: ${stream.name}`);
-    console.log(`  latest: ${latestMicros ? formatDate(latestMicros) : "missing"}`);
+    console.log(
+      `  latest: ${latestMicros ? formatDate(latestMicros) : "missing"}`,
+    );
     console.log(`  age: ${formatAgeSeconds(ageSeconds)}`);
     console.log(`  docs: ${item?.stats?.doc_num ?? 0}`);
   }
 
   console.log("");
   console.log("Local proxy summary log:");
-  if (!localSummary || !localSummaryMicros) {
+  if (otelOnly) {
+    console.log(
+      "  disabled (OTel-only mode); local file freshness is not a delivery check",
+    );
+  } else if (!localSummary || !localSummaryMicros) {
     console.log("  missing");
     hasProblem = true;
   } else {
-    const ageSeconds = Math.max(0, (nowMicros - localSummaryMicros) / 1_000_000);
+    const ageSeconds = Math.max(
+      0,
+      (nowMicros - localSummaryMicros) / 1_000_000,
+    );
     console.log(`  latest: ${localSummary.timestamp}`);
     console.log(`  age: ${formatAgeSeconds(ageSeconds)}`);
     console.log(`  requestId: ${localSummary.requestId}`);
@@ -220,7 +231,9 @@ async function main() {
       if (status !== "fresh") {
         hasProblem = true;
       }
-      console.log(`  ${stream.name}: ${status} (${formatAgeSeconds(deltaSeconds)})`);
+      console.log(
+        `  ${stream.name}: ${status} (${formatAgeSeconds(deltaSeconds)})`,
+      );
     }
   }
 

package/scripts/observability/query-proxy-history.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/** Bounded, deterministic OpenObserve history queries; never accept partial data. */
+import { pathToFileURL } from "node:url";
+
+const KINDS = new Set([
+  "request_final",
+  "attempt",
+  "lifecycle",
+  "supervisor",
+  "body_capture_index",
+  "stream_error",
+]);
+
+/**
+ * Query metadata in small windows; body chunks require a targeted lookup.
+ * @param {{ baseUrl: string, organization?: string, stream?: string, authorization?: string, startTime: number, endTime: number, kind?: string, maxRows?: number, fetchImpl?: typeof fetch }} options
+ */
+export async function queryProxyHistory({
+  baseUrl,
+  organization = "default",
+  stream = "neurolink_proxy",
+  authorization,
+  startTime,
+  endTime,
+  kind = "request_final",
+  maxRows = 10_000,
+  fetchImpl = fetch,
+}) {
+  if (
+    !/^[a-zA-Z0-9_-]+$/.test(organization) ||
+    !/^[a-zA-Z0-9_]+$/.test(stream) ||
+    !KINDS.has(kind)
+  ) {
+    throw new Error("Invalid organization, stream or metadata record kind");
+  }
+  if (
+    !Number.isSafeInteger(startTime) ||
+    !Number.isSafeInteger(endTime) ||
+    startTime >= endTime ||
+    !Number.isSafeInteger(maxRows) ||
+    maxRows < 1 ||
+    maxRows > 100_000
+  ) {
+    throw new Error(
+      "Provide an increasing microsecond time range and maxRows between 1 and 100000",
+    );
+  }
+  const endpoint = new URL(`/api/${organization}/_search?type=logs`, baseUrl);
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(endpoint.hostname);
+  if (authorization && endpoint.protocol !== "https:" && !(
+    endpoint.protocol === "http:" && loopback
+  )) {
+    throw new Error("Credentialed OpenObserve queries require HTTPS outside loopback");
+  }
+  /** @type {Array<{start: number, endExclusive: number, offset: number, partial: boolean, tookMs?: number}>} */
+  const queries = [];
+  let rowsRead = 0;
+  /** @param {number} start @param {number} end @returns {Promise<Array<Record<string, unknown>>>} */
+  async function readWindow(start, end) {
+    const rows = [];
+    for (let offset = 0; ; offset += 200) {
+      if (queries.length >= 512) {
+        throw new Error(
+          "History exceeds the 512-query budget; narrow the interval",
+        );
+      }
+      const response = await fetchImpl(endpoint, {
+        method: "POST",
+        redirect: authorization ? "error" : "follow",
+        signal: globalThis.AbortSignal.timeout(30_000),
+        headers: {
+          "Content-Type": "application/json",
+          ...(authorization ? { Authorization: authorization } : {}),
+        },
+        body: JSON.stringify({
+          query: {
+            // The body is small metadata, not arbitrary request/response chunks.
+            // Include a secondary key: timestamp-only paging loses equal-time events.
+            sql: `SELECT _timestamp, service_instance_id, request_id, body FROM "${stream}" WHERE proxy_record_kind='${kind}' ORDER BY _timestamp ASC, service_instance_id ASC, request_id ASC, body ASC`,
+            start_time: start,
+            end_time: end - 1,
+            from: offset,
+            size: 200,
+          },
+        }),
+      });
+      if (!response.ok) {
+        throw new Error(`OpenObserve search failed: HTTP ${response.status}`);
+      }
+      const result = await response.json();
+      const partial =
+        result.is_partial === true ||
+        (Array.isArray(result.function_error)
+          ? result.function_error.length > 0
+          : Boolean(result.function_error));
+      queries.push({
+        start,
+        endExclusive: end,
+        offset,
+        partial,
+        tookMs: result.took,
+      });
+      if (partial) {
+        // Discard this window's pages before splitting, so no page is duplicated.
+        if (end - start <= 10_000_000) {
+          throw new Error(
+            "OpenObserve still returned partial data in a 10-second window; no complete report can be produced",
+          );
+        }
+        rowsRead -= rows.length;
+        const middle = Math.floor((start + end) / 2);
+        return [
+          ...(await readWindow(start, middle)),
+          ...(await readWindow(middle, end)),
+        ];
+      }
+      if (!Array.isArray(result.hits)) {
+        throw new Error("OpenObserve search omitted hits");
+      }
+      rowsRead += result.hits.length;
+      if (rowsRead > maxRows) {
+        throw new Error(
+          `History exceeds the explicit ${maxRows}-row bound; narrow the interval or increase --max-rows`,
+        );
+      }
+      rows.push(...result.hits);
+      if (result.hits.length < 200) {
+        return rows;
+      }
+    }
+  }
+  const records = [];
+  for (let start = startTime; start < endTime; start += 600_000_000) {
+    records.push(
+      ...(await readWindow(start, Math.min(start + 600_000_000, endTime))),
+    );
+  }
+  return {
+    startTime,
+    endTimeExclusive: endTime,
+    kind,
+    complete: true,
+    recordCount: records.length,
+    queries,
+    records,
+  };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  /** @param {string} name */
+  const value = (name) => {
+    const index = args.indexOf(name);
+    return index < 0 ? undefined : args[index + 1];
+  };
+  if (args.includes("--help")) {
+    console.log(
+      "Usage: node scripts/observability/query-proxy-history.mjs --since ISO_DATE [--until ISO_DATE] [--kind request_final|attempt|lifecycle|supervisor|body_capture_index|stream_error] [--max-rows 10000]",
+    );
+    return;
+  }
+  const since = Date.parse(value("--since") ?? "");
+  const untilValue = value("--until");
+  const until = untilValue ? Date.parse(untilValue) : Date.now();
+  const user = process.env.NEUROLINK_OPENOBSERVE_USER;
+  const password = process.env.NEUROLINK_OPENOBSERVE_PASSWORD;
+  const authorization =
+    process.env.NEUROLINK_OPENOBSERVE_BASIC_AUTH ??
+    (user && password
+      ? `Basic ${Buffer.from(`${user}:${password}`).toString("base64")}`
+      : undefined);
+  const report = await queryProxyHistory({
+    baseUrl: process.env.NEUROLINK_OPENOBSERVE_URL ?? "http://127.0.0.1:5080",
+    organization: process.env.NEUROLINK_OPENOBSERVE_ORG ?? "default",
+    stream: process.env.NEUROLINK_PROXY_STREAM_HEADER ?? "neurolink_proxy",
+    authorization,
+    startTime: since * 1000,
+    endTime: until * 1000,
+    kind: value("--kind") ?? "request_final",
+    maxRows: Number(value("--max-rows") ?? 10_000),
+  });
+  console.log(JSON.stringify(report, null, 2));
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exitCode = 1;
+  });
+}