@juspay/neurolink 12.14.6 → 12.14.7

package/dist/proxy/proxyTracer.js

@@ -13,12 +13,13 @@
  * - calculateCost() from pricing.ts for cost tracking
  * - TelemetryService for metrics recording
  */
-import { SpanStatusCode, context, metrics, trace, } from "@opentelemetry/api";
+import { SpanStatusCode, SpanKind, ROOT_CONTEXT, isSpanContextValid, propagation, context, metrics, trace, } from "@opentelemetry/api";
 import { getTracer, setLangfuseContext, } from "../services/server/ai/observability/instrumentation.js";
 import { OtelBridge } from "../observability/otelBridge.js";
 import { calculateCost } from "../utils/pricing.js";
 import { TelemetryService } from "../telemetry/telemetryService.js";
 import { logger } from "../utils/logger.js";
+import { registerProxyRequestTraceContext, releaseProxyRequestTraceContext, } from "./proxyTraceContext.js";
 const LOG_PREFIX = "[ProxyTracer]";
 // ---------------------------------------------------------------------------
 // OTEL Metric Instruments — lazy singleton
@@ -205,6 +206,8 @@ class ProxyTracer {
     billingProvider;
     startTime;
     isStream;
+    ended = false;
+    recordRequestMetrics = true;
     accountEmail;
     usage;
     mode = "full";
@@ -226,7 +229,7 @@ class ProxyTracer {
         const tracer = getTracer("neurolink.proxy");
         // Extract parent context from incoming headers (Claude Code may send traceparent)
         let parentContext = context.active();
-        if (incomingHeaders) {
+        if (incomingHeaders && !trace.getSpan(context.active())) {
             const bridge = new OtelBridge();
             const extracted = bridge.extractContext(incomingHeaders);
             if (extracted) {
@@ -270,6 +273,7 @@ class ProxyTracer {
             rootSpan.setAttribute("neurolink.conversation_id", nlConversationId);
         }
         const instance = new ProxyTracer(rootSpan, ctx.requestId, ctx.model, ctx.stream, ctx.provider ?? "anthropic");
+        instance.recordRequestMetrics = ctx.recordRequestMetrics !== false;
         // Set Langfuse context (fire-and-forget — non-blocking)
         // Prefer NeuroLink session/user from calling SDK over Claude Code session
         setLangfuseContext({
@@ -607,6 +611,7 @@ class ProxyTracer {
         return {
             traceId: spanCtx.traceId,
             spanId: spanCtx.spanId,
+            traceFlags: spanCtx.traceFlags,
         };
     }
     /** Return the captured usage (set by setUsage). */
@@ -618,6 +623,10 @@ class ProxyTracer {
     // -------------------------------------------------------------------------
     /** End the root span with final HTTP status and duration, and emit OTEL metrics. */
     end(responseStatus, durationMs) {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
         this.rootSpan.setAttributes({
             "http.status_code": responseStatus,
             "proxy.duration_ms": durationMs,
@@ -636,6 +645,9 @@ class ProxyTracer {
             this.rootSpan.setStatus({ code: SpanStatusCode.OK });
         }
         this.rootSpan.end();
+        if (!this.recordRequestMetrics) {
+            return;
+        }
         // ---- Emit OTEL metrics (lazy-init instruments) ----
         const m = getProxyMetrics();
         const labels = {
@@ -745,3 +757,70 @@ export function recordFallbackAttempt(attrs) {
     }
 }
 export { ProxyTracer };
+/** Standard SERVER span covers every proxy door, including parsing and admission failures. */
+export function startProxyHttpTrace(metadata, headers) {
+    try {
+        // Match OtelBridge's existing compatibility policy for HTTP-combined
+        // traceparent values: retain the first injected parent.
+        const normalizedHeaders = { ...headers };
+        if (normalizedHeaders.traceparent?.includes(",")) {
+            normalizedHeaders.traceparent = normalizedHeaders.traceparent
+                .split(",", 1)[0]
+                .trim();
+        }
+        const parent = propagation.extract(ROOT_CONTEXT, normalizedHeaders);
+        const span = getTracer("neurolink.proxy").startSpan("proxy.http.request", {
+            kind: SpanKind.SERVER,
+            attributes: {
+                "http.request.method": metadata.method,
+                "url.path": metadata.path,
+                "proxy.request_id": metadata.requestId,
+            },
+        }, parent);
+        const spanContext = span.spanContext();
+        if (isSpanContextValid(spanContext)) {
+            metadata.traceId = spanContext.traceId;
+            metadata.spanId = spanContext.spanId;
+            metadata.traceFlags = spanContext.traceFlags;
+            registerProxyRequestTraceContext(metadata.requestId, {
+                traceId: spanContext.traceId,
+                spanId: spanContext.spanId,
+                traceFlags: spanContext.traceFlags,
+            });
+        }
+        const active = trace.setSpan(parent, span);
+        let ended = false;
+        return {
+            run: (fn) => context.with(active, fn),
+            end: (status, outcome, errorType) => {
+                if (ended) {
+                    return;
+                }
+                ended = true;
+                try {
+                    span.setAttributes({
+                        "http.response.status_code": status,
+                        "proxy.terminal_outcome": outcome,
+                        ...(errorType ? { "error.type": errorType } : {}),
+                    });
+                    if (status >= 500 ||
+                        outcome === "stream_error" ||
+                        outcome === "unknown") {
+                        span.setStatus({ code: SpanStatusCode.ERROR });
+                    }
+                    span.end();
+                }
+                catch {
+                    // Telemetry must not interrupt transport cleanup.
+                }
+                finally {
+                    releaseProxyRequestTraceContext(metadata.requestId);
+                }
+            },
+        };
+    }
+    catch {
+        releaseProxyRequestTraceContext(metadata.requestId);
+        return { run: (fn) => fn(), end: () => undefined };
+    }
+}

package/dist/proxy/requestLogger.js

@@ -21,6 +21,7 @@ import { SeverityNumber } from "@opentelemetry/api-logs";
 import { configureProxyLifecycleLogger } from "./proxyLifecycle.js";
 import { notifyProxyFinalLog, notifyProxyAttemptLog } from "./proxyActivity.js";
 import { withTimeout } from "../utils/async/withTimeout.js";
+import { resolveProxyLogTraceContext, proxyLogContext, } from "./proxyTraceContext.js";
 let logDir = null;
 let logEnabled = false;
 const pendingLogOperations = new Set();
@@ -184,6 +185,12 @@ export function initRequestLogger(enabled = true, customLogsDir) {
     }
 }
 export async function logRequest(entry) {
+    if (!entry.traceId || entry.traceFlags === undefined) {
+        const traceCtx = resolveProxyLogTraceContext(entry);
+        if (traceCtx) {
+            Object.assign(entry, traceCtx);
+        }
+    }
     entry.terminalOutcome ??=
         entry.errorType === "client_cancelled" || entry.responseStatus === 499
             ? "client_cancelled"
@@ -196,17 +203,6 @@ export async function logRequest(entry) {
     if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
-    // Only use OtelBridge if traceId not already provided by caller.
-    // Deferred .then() callbacks lose async context, so OtelBridge would
-    // return undefined and overwrite the valid traceId the caller passed.
-    if (!entry.traceId) {
-        const bridge = new OtelBridge();
-        const traceCtx = bridge.getCurrentTraceContext();
-        if (traceCtx) {
-            entry.traceId = traceCtx.traceId;
-            entry.spanId = traceCtx.spanId;
-        }
-    }
     if (isProxyOtelOnly()) {
         await emitOtlpLogRecord(entry);
         return;
@@ -228,12 +224,12 @@ export async function logRequest(entry) {
  * or OTLP-derived dashboard panels.
  */
 export async function logRequestAttempt(entry) {
-    if (!entry.traceId) {
-        const bridge = new OtelBridge();
-        const traceCtx = bridge.getCurrentTraceContext();
+    if (!entry.traceId || entry.traceFlags === undefined) {
+        const traceCtx = resolveProxyLogTraceContext(entry);
         if (traceCtx) {
             entry.traceId = traceCtx.traceId;
             entry.spanId = traceCtx.spanId;
+            entry.traceFlags = traceCtx.traceFlags;
         }
     }
     notifyProxyAttemptLog(entry);
@@ -313,6 +309,7 @@ function emitOtlpLogRecord(entry) {
             : SeverityNumber.INFO;
         const severityText = isError ? (isRateLimit ? "WARN" : "ERROR") : "INFO";
         otelLogger.emit({
+            context: proxyLogContext(entry),
             severityNumber,
             severityText,
             body: isProxyOtelOnly()
@@ -453,6 +450,7 @@ function emitOtlpBodyLogRecord(entry, stored) {
         const captureId = entry.captureId ?? randomUUID();
         const emit = (chunk, chunkIndex, totalChunks) => {
             otelLogger.emit({
+                context: proxyLogContext(entry),
                 severityNumber: (entry.responseStatus ?? 0) >= 400
                     ? SeverityNumber.WARN
                     : SeverityNumber.INFO,
@@ -526,12 +524,16 @@ export async function logBodyCapture(entry) {
     // not something a share token can be read as consenting to. The request is
     // still logged; only the bodies are dropped.
     if (isBorrowedRequest()) {
+        emitProxyOtelEvent("body_capture_index", {
+            timestamp: entry.timestamp,
+            requestId: entry.requestId,
+            captureId: entry.captureId ?? randomUUID(),
+            phase: entry.phase,
+            bodyDelivery: { status: "policy_excluded", reason: "borrowed_traffic" },
+        });
         return;
     }
-    const bridge = new OtelBridge();
-    const traceCtx = entry.traceId && entry.spanId
-        ? { traceId: entry.traceId, spanId: entry.spanId }
-        : bridge.getCurrentTraceContext();
+    const traceCtx = resolveProxyLogTraceContext(entry);
     const destination = logDir;
     // Publication callbacks retain metadata and the bounded redacted result,
     // never the original unbounded body while a sink is slow.
@@ -573,6 +575,7 @@ export async function logBodyCapture(entry) {
             originalRedactedBodyBytes: stored.originalRedactedBodyBytes,
             bodyWriteFailed: stored.bodyWriteFailed,
             captureError: processed.error,
+            captureAdmission: processed.admission,
             captureQueueWaitMs: processed.queueWaitMs,
             captureProcessingMs: processed.processingMs,
             metadata: processed.error ? undefined : metadata.metadata,
@@ -580,12 +583,14 @@ export async function logBodyCapture(entry) {
         if (traceCtx) {
             indexEntry.traceId = traceCtx.traceId;
             indexEntry.spanId = traceCtx.spanId;
+            indexEntry.traceFlags = traceCtx.traceFlags;
         }
         if (isProxyOtelOnly()) {
             const delivery = await emitOtlpBodyLogRecord({
                 ...metadata,
                 traceId: traceCtx?.traceId ?? metadata.traceId,
                 spanId: traceCtx?.spanId ?? metadata.spanId,
+                traceFlags: traceCtx?.traceFlags ?? metadata.traceFlags,
             }, stored);
             indexEntry.bodyDelivery = delivery ?? {
                 status: processed.error
@@ -612,6 +617,7 @@ export async function logBodyCapture(entry) {
             ...metadata,
             traceId: traceCtx?.traceId ?? metadata.traceId,
             spanId: traceCtx?.spanId ?? metadata.spanId,
+            traceFlags: traceCtx?.traceFlags ?? metadata.traceFlags,
         }, stored);
     };
     const operation = trackLogOperation(captureProxyBody(entry, destination, consume));