@juspay/neurolink 12.14.0 → 12.14.2

package/dist/proxy/proxyLifecycle.js

@@ -1,3 +1,4 @@
+import { emitProxyOtelEvent, isProxyOtelOnly, initializeProxyOtelLogs, } from "./otelLogSink.js";
 import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { appendFile } from "node:fs/promises";
@@ -297,6 +298,25 @@ export function configureProxyLifecycleLogger(options) {
     batchSize = positiveInteger(options.batchSize, DEFAULT_BATCH_SIZE);
     maxWriteRetries = positiveInteger(options.maxWriteRetries, DEFAULT_MAX_WRITE_RETRIES);
     flushIntervalMs = positiveInteger(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
+    if (options.enabled && isProxyOtelOnly()) {
+        initializeProxyOtelLogs(options.filePrefix === "proxy-supervisor" ? "supervisor" : "worker");
+        loggerEnabled = true;
+        sessionHashKey = process.env.NEUROLINK_PROXY_SESSION_SECRET
+            ? createHash("sha256")
+                .update(process.env.NEUROLINK_PROXY_SESSION_SECRET)
+                .digest()
+            : sessionHashKey;
+        stopRuntimeMetrics = startProxyRuntimeMetrics((runtimeSample) => {
+            logProxyLifecycleEvent({
+                event: "runtime_sample",
+                requestId: "-",
+                method: "-",
+                path: "-",
+                runtimeSample,
+            });
+        });
+        return;
+    }
     if (options.enabled && options.logDir) {
         try {
             mkdirSync(options.logDir, { recursive: true, mode: 0o700 });
@@ -336,7 +356,7 @@ export function logProxyLifecycleEvent(input) {
  * capacity is unavailable.
  */
 function enqueueLifecycleEvent(input, onPersisted) {
-    if (!loggerEnabled || !lifecycleLogDir) {
+    if (!loggerEnabled || (!lifecycleLogDir && !isProxyOtelOnly())) {
         onPersisted?.(false);
         return;
     }
@@ -406,6 +426,10 @@ function enqueueLifecycleEvent(input, onPersisted) {
                 : {}),
             ...(input.runtimeSample ? { runtimeSample: input.runtimeSample } : {}),
         };
+        if (isProxyOtelOnly()) {
+            emitProxyOtelEvent(filePrefix === "proxy-supervisor" ? "supervisor" : "lifecycle", record);
+            return;
+        }
         queue.push({
             filePrefix,
             logDir: lifecycleLogDir,
@@ -431,6 +455,10 @@ export async function persistProxyLifecycleAcceptance(input, timeoutMs = LIFECYC
     if (!loggerRequired) {
         return;
     }
+    if (isProxyOtelOnly()) {
+        enqueueLifecycleEvent({ ...input, event: "request_accepted" });
+        return;
+    }
     const confirmed = new Promise((resolve) => {
         enqueueLifecycleEvent({ ...input, event: "request_accepted" }, resolve);
     });
@@ -462,6 +490,8 @@ export async function flushProxyLifecycleEvents(timeoutMs = 5_000) {
 export function getProxyLifecycleLoggerSnapshot() {
     return {
         enabled: loggerEnabled,
+        sink: isProxyOtelOnly() ? "otel" : "file",
+        admissionPolicy: isProxyOtelOnly() ? "best-effort" : "durable-file",
         schemaVersion: SCHEMA_VERSION,
         processInstanceId,
         nextSequence,

package/dist/proxy/requestLogger.js

@@ -5,6 +5,7 @@
  * when a LoggerProvider is configured via OpenTelemetry instrumentation.
  * Useful for debugging and auditing proxy traffic.
  */
+import { emitProxyOtelEvent, getProxyOtelLogSnapshot, initializeProxyOtelLogs, isProxyOtelOnly, } from "./otelLogSink.js";
 import { join } from "path";
 import { homedir } from "os";
 import { logger } from "../utils/logger.js";
@@ -46,6 +47,8 @@ const metadataSinks = {
 export function getRequestLoggerSnapshot() {
     return {
         enabled: logEnabled,
+        diskEnabled: logEnabled && !isProxyOtelOnly(),
+        otel: getProxyOtelLogSnapshot(),
         requests: { ...metadataSinks.requests },
         attempts: { ...metadataSinks.attempts },
         debug: { ...metadataSinks.debug },
@@ -155,6 +158,12 @@ export function initRequestLogger(enabled = true, customLogsDir) {
         configureProxyLifecycleLogger({ enabled: false });
         return;
     }
+    if (isProxyOtelOnly()) {
+        initializeProxyOtelLogs();
+        logDir = null;
+        configureProxyLifecycleLogger({ enabled: true });
+        return;
+    }
     try {
         logDir = customLogsDir ?? join(homedir(), ".neurolink", "logs");
         if (!existsSync(logDir)) {
@@ -183,7 +192,7 @@ export async function logRequest(entry) {
                     ? "handler_error"
                     : "completed";
     notifyProxyFinalLog(entry);
-    if (!logEnabled || !logDir) {
+    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
     // Only use OtelBridge if traceId not already provided by caller.
@@ -197,6 +206,10 @@ export async function logRequest(entry) {
             entry.spanId = traceCtx.spanId;
         }
     }
+    if (isProxyOtelOnly()) {
+        await emitOtlpLogRecord(entry);
+        return;
+    }
     const logFile = join(logDir, `proxy-${new Date().toISOString().split("T")[0]}.jsonl`);
     const line = JSON.stringify(entry) + "\n";
     try {
@@ -206,7 +219,7 @@ export async function logRequest(entry) {
         // Non-fatal — don't crash proxy for logging failures
     }
     // Emit OTLP log record (additive — file logging is the primary sink)
-    emitOtlpLogRecord(entry);
+    void emitOtlpLogRecord(entry);
 }
 /**
  * Log an upstream attempt separately from the final request outcome.
@@ -214,7 +227,7 @@ export async function logRequest(entry) {
  * or OTLP-derived dashboard panels.
  */
 export async function logRequestAttempt(entry) {
-    if (!logEnabled || !logDir) {
+    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
     if (!entry.traceId) {
@@ -225,6 +238,10 @@ export async function logRequestAttempt(entry) {
             entry.spanId = traceCtx.spanId;
         }
     }
+    if (isProxyOtelOnly()) {
+        emitProxyOtelEvent("attempt", entry);
+        return;
+    }
     const logFile = join(logDir, `proxy-attempts-${new Date().toISOString().split("T")[0]}.jsonl`);
     const line = JSON.stringify(entry) + "\n";
     try {
@@ -242,6 +259,9 @@ export async function logRequestAttempt(entry) {
  * where OTel initialization completes after the first log request.
  */
 async function resolveLoggerProvider() {
+    if (isProxyOtelOnly()) {
+        return initializeProxyOtelLogs();
+    }
     if (otelLoggerProvider === false) {
         return undefined;
     } // permanently unavailable
@@ -275,7 +295,7 @@ async function resolveLoggerProvider() {
  * Non-blocking, non-fatal — failures are silently swallowed.
  */
 function emitOtlpLogRecord(entry) {
-    resolveLoggerProvider()
+    return resolveLoggerProvider()
         .then((provider) => {
         if (!provider) {
             return;
@@ -293,8 +313,11 @@ function emitOtlpLogRecord(entry) {
         otelLogger.emit({
             severityNumber,
             severityText,
-            body: `${entry.method} ${entry.path} → ${entry.responseStatus} (${entry.responseTimeMs}ms)`,
+            body: isProxyOtelOnly()
+                ? JSON.stringify(entry)
+                : `${entry.method} ${entry.path} → ${entry.responseStatus} (${entry.responseTimeMs}ms)`,
             attributes: {
+                "proxy.record_kind": "request_final",
                 // Core request fields
                 "request.id": entry.requestId,
                 "http.method": entry.method,
@@ -440,6 +463,7 @@ function emitOtlpBodyLogRecord(entry, stored) {
                 body: chunk,
                 attributes: {
                     "event.name": "proxy.body_capture",
+                    "proxy.record_kind": "body",
                     "request.id": entry.requestId,
                     "body.phase": entry.phase,
                     "body.chunk_index": chunkIndex,
@@ -484,7 +508,7 @@ function emitOtlpBodyLogRecord(entry, stored) {
 }
 /** Capture an owned request body with bounded processing and tracked index/export publication. */
 export async function logBodyCapture(entry) {
-    if (!logEnabled || !logDir) {
+    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
     // Borrowed traffic is somebody else's conversation. Capturing it would leave
@@ -507,7 +531,9 @@ export async function logBodyCapture(entry) {
         const redactedHeaders = processed.headers;
         const stored = processed.stored;
         const dateStr = new Date(metadata.timestamp).toISOString().split("T")[0];
-        const logFile = join(destination, `proxy-debug-${dateStr}.jsonl`);
+        const logFile = destination
+            ? join(destination, `proxy-debug-${dateStr}.jsonl`)
+            : undefined;
         const indexEntry = {
             timestamp: metadata.timestamp,
             type: "body_capture",
@@ -538,8 +564,13 @@ export async function logBodyCapture(entry) {
             indexEntry.traceId = traceCtx.traceId;
             indexEntry.spanId = traceCtx.spanId;
         }
+        if (isProxyOtelOnly()) {
+            emitProxyOtelEvent("body_capture_index", indexEntry);
+        }
         try {
-            await appendMetadataRecord(logFile, JSON.stringify(indexEntry) + "\n", "debug", { waitForPersistence: true });
+            if (logFile) {
+                await appendMetadataRecord(logFile, JSON.stringify(indexEntry) + "\n", "debug", { waitForPersistence: true });
+            }
         }
         catch {
             // Non-fatal
@@ -596,12 +627,11 @@ export async function logFullRequestResponse(entry) {
  * These are invisible in normal request logs since the 200 was already recorded.
  */
 export async function logStreamError(entry) {
-    if (!logEnabled || !logDir) {
+    if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
     const bridge = new OtelBridge();
     const traceCtx = bridge.getCurrentTraceContext();
-    const logFile = join(logDir, `proxy-${new Date().toISOString().split("T")[0]}.jsonl`);
     const logEntry = {
         ...entry,
         responseStatus: 200,
@@ -614,6 +644,11 @@ export async function logStreamError(entry) {
         logEntry.traceId = traceCtx.traceId;
         logEntry.spanId = traceCtx.spanId;
     }
+    if (isProxyOtelOnly()) {
+        emitProxyOtelEvent("stream_error", logEntry);
+        return;
+    }
+    const logFile = join(logDir, `proxy-${new Date().toISOString().split("T")[0]}.jsonl`);
     try {
         await appendMetadataRecord(logFile, JSON.stringify(logEntry) + "\n", "requests");
     }

package/dist/proxy/workerLog.js

@@ -1,8 +1,12 @@
+import { isProxyOtelOnly } from "./otelLogSink.js";
 import { chmodSync, closeSync, existsSync, mkdirSync, openSync, statSync, } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 /** Open a restrictive worker log without making proxy startup depend on it. */
 export function openProxyWorkerLog(filename, logDir = join(homedir(), ".neurolink", "logs")) {
+    if (isProxyOtelOnly()) {
+        return { stdio: "ignore", close: () => undefined };
+    }
     let fd;
     try {
         if (basename(filename) !== filename) {

package/dist/types/aiCompat.d.ts

@@ -275,6 +275,7 @@ export type LanguageModelV3Content = {
 } | {
     type: "reasoning";
     text: string;
+    providerOptions?: Record<string, Record<string, unknown>>;
 } | {
     type: "file";
     data: unknown;

package/dist/types/proxy.d.ts

@@ -644,6 +644,8 @@ export type ProxyBodyCaptureWorkerSnapshot = {
     lastError?: string;
 };
 export type ProxyRequestLoggerSnapshot = {
+    diskEnabled?: boolean;
+    otel?: ReturnType<typeof import("../proxy/otelLogSink.js").getProxyOtelLogSnapshot>;
     bodyCapture?: ProxyBodyCaptureWorkerSnapshot;
     enabled: boolean;
     requests: ProxyRequestLogSinkSnapshot;
@@ -1685,6 +1687,8 @@ export type ProxyRuntimeSample = {
 };
 /** Data-quality counters for the bounded lifecycle metadata sink. */
 export type ProxyLifecycleLoggerSnapshot = {
+    sink?: "otel" | "file";
+    admissionPolicy?: "best-effort" | "durable-file";
     enabled: boolean;
     schemaVersion: number;
     processInstanceId: string;