@juspay/neurolink 12.58.1 → 13.0.0

package/dist/proxy/proxyTracer.js

@@ -6,22 +6,20 @@
  *   receive -> account_selection -> upstream (per retry) -> stream -> end
  *
  * Uses the existing instrumentation infrastructure:
- * - getTracer() from instrumentation.ts for span creation
  * - setLangfuseContext() for Langfuse enrichment
- * - OtelBridge for context propagation to/from upstream
+ * - OTel propagation API for context propagation to/from upstream
  * - SpanAttributes from spanTypes.ts for attribute naming
  * - calculateCost() from pricing.ts for cost tracking
- * - TelemetryService for metrics recording
  */
 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 { setLangfuseContext } from "../services/server/ai/observability/instrumentation.js";
+import { spanContentAttribute } from "../telemetry/attributes.js";
+import { observationLevel, observe, observeTrace, usageDetails, } from "../telemetry/observation.js";
+import { generationName } from "../telemetry/observationNames.js";
 import { proxyTokenUsage } from "./proxyTokenUsage.js";
 import { calculateCost, hasPricing, isExactPricingMatch, } 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
 //
@@ -36,7 +34,7 @@ function getProxyMetrics() {
     if (_metrics) {
         return _metrics;
     }
-    const meter = metrics.getMeter("neurolink.proxy", "1.0.0");
+    const meter = metrics.getMeter("proxy", "1.0.0");
     const createdMetrics = {
         requestsTotal: meter.createCounter("proxy_requests_total", {
             description: "Total number of proxy requests",
@@ -178,6 +176,14 @@ function buildBodyEventAttributes(body) {
         "proxy.body.truncated": body.length > MAX_BODY_LOG_SIZE,
     };
 }
+function parseBody(body) {
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return body;
+    }
+}
 // ---------------------------------------------------------------------------
 // Client app detection
 // ---------------------------------------------------------------------------
@@ -198,8 +204,8 @@ function detectClientApp(userAgent) {
 // ---------------------------------------------------------------------------
 class ProxyTracer {
     rootSpan;
-    proxyTracer = getTracer("neurolink.proxy");
-    bridge = new OtelBridge();
+    traceContext;
+    proxyTracer = trace.getTracer("proxy");
     requestId;
     /**
      * Model used for costing. Starts as the model the client asked for and is
@@ -223,10 +229,21 @@ class ProxyTracer {
     mode = "full";
     /** Where the Claude-shaped request originated, for cache/cost attribution. */
     requestOrigin = "native";
-    constructor(rootSpan, requestId, model, stream, billingProvider) {
+    requestedModel;
+    input;
+    output;
+    responseModel;
+    finishReason;
+    firstOutputAt;
+    upstreamStartedAt;
+    cost;
+    statusMessage;
+    constructor(rootSpan, traceContext, requestId, model, stream, billingProvider) {
         this.rootSpan = rootSpan;
+        this.traceContext = traceContext;
         this.requestId = requestId;
         this.model = model;
+        this.requestedModel = model;
         this.billingProvider = billingProvider;
         this.startTime = Date.now();
         this.isStream = stream;
@@ -235,35 +252,47 @@ class ProxyTracer {
      * Create a root span for a proxy request and set Langfuse context.
      *
      * If the incoming request carries a `traceparent` header, the root span
-     * will be linked to the caller's trace via OtelBridge.extractContext().
+     * will be linked to the caller's trace via the OTel propagation API.
      */
     static startRequest(ctx, incomingHeaders) {
-        const tracer = getTracer("neurolink.proxy");
+        const tracer = trace.getTracer("proxy");
         // Extract parent context from incoming headers (Claude Code may send traceparent)
         let parentContext = context.active();
         if (incomingHeaders && !trace.getSpan(context.active())) {
-            const bridge = new OtelBridge();
-            const extracted = bridge.extractContext(incomingHeaders);
+            const headers = { ...incomingHeaders };
+            if (headers["traceparent"]?.includes(", ")) {
+                headers["traceparent"] = headers["traceparent"].split(", ")[0];
+            }
+            const extracted = trace.getSpanContext(propagation.extract(context.active(), headers));
             if (extracted) {
                 // Create a remote span context so the root span becomes a child of the caller
                 parentContext = trace.setSpanContext(context.active(), extracted);
             }
         }
         const clientApp = ctx.clientApp ?? detectClientApp(ctx.userAgent);
+        const traceContext = context.with(parentContext, () => setLangfuseContext({
+            userId: incomingHeaders?.["x-neurolink-user-id"],
+            sessionId: incomingHeaders?.["x-neurolink-session-id"] ?? ctx.sessionId,
+            conversationId: incomingHeaders?.["x-neurolink-conversation-id"],
+            requestId: ctx.requestId,
+            traceName: `proxy:${ctx.model}`,
+            metadata: {
+                clientApp,
+                stream: ctx.stream,
+                toolCount: ctx.toolCount,
+            },
+        }, () => context.active()));
         const rootSpan = tracer.startSpan("proxy.request", {
             attributes: {
                 "proxy.request_id": ctx.requestId,
                 "http.method": ctx.method,
                 "http.target": ctx.path,
-                "gen_ai.request.model": ctx.model,
+                "proxy.request.model": ctx.model,
                 "proxy.stream": ctx.stream,
                 "proxy.tool_count": ctx.toolCount,
                 "proxy.client_app": clientApp,
             },
-        }, parentContext);
-        if (ctx.sessionId) {
-            rootSpan.setAttribute("session.id", ctx.sessionId);
-        }
+        }, traceContext);
         if (ctx.userAgent) {
             rootSpan.setAttribute("http.user_agent", ctx.userAgent);
         }
@@ -271,42 +300,10 @@ class ProxyTracer {
             // What the caller exposed to the model (tool catalogue for this request).
             rootSpan.setAttribute("gen_ai.request.tool_names", JSON.stringify(ctx.toolNames));
         }
-        // Read x-neurolink-* context headers from calling SDK (e.g., Curator)
-        const nlSessionId = incomingHeaders?.["x-neurolink-session-id"];
-        const nlUserId = incomingHeaders?.["x-neurolink-user-id"];
-        const nlConversationId = incomingHeaders?.["x-neurolink-conversation-id"];
-        if (nlSessionId) {
-            rootSpan.setAttribute("neurolink.session_id", nlSessionId);
-        }
-        if (nlUserId) {
-            rootSpan.setAttribute("neurolink.user_id", nlUserId);
-        }
-        if (nlConversationId) {
-            rootSpan.setAttribute("neurolink.conversation_id", nlConversationId);
-        }
-        const instance = new ProxyTracer(rootSpan, ctx.requestId, ctx.model, ctx.stream, ctx.provider ?? "anthropic");
+        const instance = new ProxyTracer(rootSpan, trace.setSpan(traceContext, rootSpan), ctx.requestId, ctx.model, ctx.stream, ctx.provider ?? "anthropic");
         instance.recordRequestMetrics = ctx.recordRequestMetrics !== false;
         instance.recordUsageMetrics =
             ctx.recordUsageMetrics ?? instance.recordRequestMetrics;
-        // Set Langfuse context (fire-and-forget — non-blocking)
-        // Prefer NeuroLink session/user from calling SDK over Claude Code session
-        setLangfuseContext({
-            sessionId: nlSessionId ?? ctx.sessionId,
-            userId: nlUserId,
-            conversationId: nlConversationId,
-            requestId: ctx.requestId,
-            traceName: `proxy:${ctx.model}`,
-            operationName: "proxy.request",
-            metadata: {
-                clientApp,
-                stream: ctx.stream,
-                toolCount: ctx.toolCount,
-            },
-        }).catch((err) => {
-            logger.debug(`${LOG_PREFIX} Failed to set Langfuse context`, {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        });
         return instance;
     }
     // -------------------------------------------------------------------------
@@ -318,7 +315,7 @@ class ProxyTracer {
             attributes: {
                 "proxy.request_id": this.requestId,
             },
-        }, trace.setSpan(context.active(), this.rootSpan));
+        }, this.traceContext);
     }
     /** Span covering account selection logic (fill-first / round-robin). */
     startAccountSelection() {
@@ -326,10 +323,11 @@ class ProxyTracer {
             attributes: {
                 "proxy.request_id": this.requestId,
             },
-        }, trace.setSpan(context.active(), this.rootSpan));
+        }, this.traceContext);
     }
     /** Span covering a single upstream attempt. One per retry. */
     startUpstreamAttempt(ctx) {
+        this.upstreamStartedAt ??= Date.now();
         return this.proxyTracer.startSpan("proxy.upstream", {
             attributes: {
                 "proxy.request_id": this.requestId,
@@ -339,16 +337,16 @@ class ProxyTracer {
                 "proxy.upstream.polyfill_body": ctx.polyfillBody,
                 "http.url": ctx.upstreamUrl,
             },
-        }, trace.setSpan(context.active(), this.rootSpan));
+        }, this.traceContext);
     }
     /** Span covering the SSE stream relay phase. */
     startStream() {
         return this.proxyTracer.startSpan("proxy.stream", {
             attributes: {
                 "proxy.request_id": this.requestId,
-                "gen_ai.request.model": this.model,
+                "proxy.request.model": this.model,
             },
-        }, trace.setSpan(context.active(), this.rootSpan));
+        }, this.traceContext);
     }
     // -------------------------------------------------------------------------
     // Attribute setters
@@ -369,10 +367,6 @@ class ProxyTracer {
         if (ctx.rateLimitBefore7d !== undefined) {
             this.rootSpan.setAttribute("proxy.ratelimit.before.7d", ctx.rateLimitBefore7d);
         }
-        // Update Langfuse context with account as userId
-        setLangfuseContext({ userId: ctx.selectedAccount }).catch(() => {
-            // Non-fatal
-        });
     }
     /** Attribute fallback metrics to the account that actually served them. */
     setServedAccount(account, accountType) {
@@ -416,11 +410,10 @@ class ProxyTracer {
         if (ctx.reasoningTokens !== undefined) {
             this.rootSpan.setAttribute("ai.tokens.reasoning", ctx.reasoningTokens);
         }
-        // GenAI semantic convention attributes (for Langfuse compatibility)
         this.rootSpan.setAttributes({
-            "gen_ai.usage.input_tokens": totalTokens - ctx.outputTokens,
-            "gen_ai.usage.output_tokens": ctx.outputTokens,
-            "gen_ai.usage.total_tokens": totalTokens,
+            "proxy.usage.input_tokens": totalTokens - ctx.outputTokens,
+            "proxy.usage.output_tokens": ctx.outputTokens,
+            "proxy.usage.total_tokens": totalTokens,
         });
         // Prefix-inferred prices are not an observed model rate. Keep provenance,
         // but emit an amount only when this model has an exact price-table entry.
@@ -435,6 +428,7 @@ class ProxyTracer {
         });
         if (pricingStatus === "exact") {
             const cost = calculateCost(this.billingProvider, this.model, billingUsage);
+            this.cost = cost;
             this.rootSpan.setAttributes({
                 "ai.cost.total": cost,
                 "ai.cost.currency": "USD",
@@ -454,8 +448,14 @@ class ProxyTracer {
      * invoked (tool_use blocks). Uses gen_ai.* semantic-convention attributes.
      */
     setResponseInfo(ctx) {
+        this.responseModel = ctx.responseModel ?? this.responseModel;
+        this.finishReason = ctx.finishReason ?? this.finishReason;
+        this.firstOutputAt = ctx.firstOutputAt ?? this.firstOutputAt;
+        if (BODY_LOGGING_ENABLED && ctx.output !== undefined) {
+            this.output = ctx.output;
+        }
         if (ctx.responseModel) {
-            this.rootSpan.setAttribute("gen_ai.response.model", ctx.responseModel);
+            this.rootSpan.setAttribute("proxy.response.model", ctx.responseModel);
         }
         if (ctx.finishReason) {
             this.rootSpan.setAttribute("gen_ai.response.finish_reason", ctx.finishReason);
@@ -475,6 +475,7 @@ class ProxyTracer {
     }
     /** Record an error on the root span. */
     setError(errorType, errorMessage) {
+        this.statusMessage = `${errorType}: ${errorMessage}`;
         this.rootSpan.setAttributes({
             "error.type": errorType,
             "error.message": errorMessage,
@@ -504,7 +505,7 @@ class ProxyTracer {
             "proxy.model_substituted": true,
             "proxy.original_model": requestedModel,
             "proxy.actual_model": actualModel,
-            "gen_ai.response.model": actualModel,
+            "proxy.response.model": actualModel,
             ...(actualProvider ? { "proxy.actual_provider": actualProvider } : {}),
         });
         if (this.recordRequestMetrics) {
@@ -539,6 +540,7 @@ class ProxyTracer {
             });
             return;
         }
+        this.input = parseBody(body);
         this.rootSpan.addEvent("proxy.client.request_body", {
             ...buildBodyEventAttributes(body),
         });
@@ -583,6 +585,7 @@ class ProxyTracer {
             });
             return;
         }
+        this.output = parseBody(body);
         this.rootSpan.addEvent("proxy.upstream.response_body", {
             ...buildBodyEventAttributes(body),
         });
@@ -624,6 +627,7 @@ class ProxyTracer {
     // -------------------------------------------------------------------------
     /** Record an upstream retry attempt. */
     recordRetry(account, reason) {
+        this.statusMessage ??= `retried: ${reason}`;
         const m = getProxyMetrics();
         m.retriesTotal.add(1, {
             model: this.model,
@@ -687,6 +691,7 @@ class ProxyTracer {
         else {
             this.rootSpan.setStatus({ code: SpanStatusCode.OK });
         }
+        this.observeOutcome(responseStatus);
         this.rootSpan.end();
         if (!this.recordRequestMetrics && !this.recordUsageMetrics) {
             return;
@@ -759,19 +764,60 @@ class ProxyTracer {
             });
         }
     }
-    /** Record metrics via TelemetryService (call after setUsage). */
-    recordMetrics() {
-        if (!this.recordUsageMetrics || !this.usage) {
+    levelFor(responseStatus) {
+        if (responseStatus === 499) {
+            return "WARNING";
+        }
+        if (responseStatus >= 400) {
+            return "ERROR";
+        }
+        if (this.statusMessage) {
+            return "WARNING";
+        }
+        return observationLevel(this.finishReason);
+    }
+    observeOutcome(responseStatus) {
+        const level = this.levelFor(responseStatus);
+        const statusMessage = this.statusMessage ??
+            (responseStatus >= 400 ? `HTTP ${responseStatus}` : undefined);
+        const io = {
+            input: this.input === undefined ? undefined : spanContentAttribute(this.input),
+            output: this.output === undefined
+                ? undefined
+                : spanContentAttribute(this.output),
+        };
+        observe(this.rootSpan, "span", {
+            ...io,
+            level,
+            statusMessage,
+            metadata: { account: this.accountEmail },
+        });
+        observeTrace(this.rootSpan, io);
+        if (this.upstreamStartedAt === undefined) {
             return;
         }
-        const billingUsage = proxyTokenUsage(this.usage);
-        const totalTokens = billingUsage.total;
-        const durationMs = Date.now() - this.startTime;
-        const cost = isExactPricingMatch(this.billingProvider, this.model) &&
-            hasPricing(this.billingProvider, this.model)
-            ? calculateCost(this.billingProvider, this.model, billingUsage)
-            : undefined;
-        TelemetryService.getInstance().recordAIRequest(this.billingProvider, this.model, totalTokens, durationMs, cost);
+        const generation = this.proxyTracer.startSpan(generationName(this.isStream ? "stream" : "generate"), {
+            startTime: this.upstreamStartedAt,
+            attributes: { "proxy.request_id": this.requestId },
+        }, this.traceContext);
+        observe(generation, "generation", {
+            ...io,
+            model: this.responseModel ?? this.model,
+            usageDetails: this.usage && usageDetails(proxyTokenUsage(this.usage)),
+            costDetails: this.cost === undefined ? undefined : { total: this.cost },
+            completionStartTime: this.firstOutputAt === undefined
+                ? undefined
+                : new Date(this.firstOutputAt),
+            level,
+            statusMessage,
+            metadata: {
+                provider: this.billingProvider,
+                account: this.accountEmail,
+                requestedModel: this.requestedModel,
+                finishReason: this.finishReason,
+            },
+        });
+        generation.end();
     }
     // -------------------------------------------------------------------------
     // Context propagation
@@ -781,7 +827,9 @@ class ProxyTracer {
      * Injects the current trace's `traceparent` / `tracestate` into a new header map.
      */
     getTraceHeaders() {
-        return this.bridge.injectContext({}, trace.setSpan(context.active(), this.rootSpan));
+        const headers = {};
+        propagation.inject(this.traceContext, headers);
+        return headers;
     }
 }
 /**
@@ -947,8 +995,6 @@ 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
@@ -956,7 +1002,7 @@ export function startProxyHttpTrace(metadata, headers) {
                 .trim();
         }
         const parent = propagation.extract(ROOT_CONTEXT, normalizedHeaders);
-        const span = getTracer("neurolink.proxy").startSpan("proxy.http.request", {
+        const span = trace.getTracer("proxy").startSpan("proxy.http.request", {
             kind: SpanKind.SERVER,
             attributes: {
                 "http.request.method": metadata.method,

package/dist/proxy/proxyTranslationEngine.js

@@ -336,7 +336,6 @@ function createTranslationRequest(args) {
                 inputIncludesCachedTokens: e.inputIncludesCachedTokens,
                 reasoningTokens: e.reasoningTokens,
             });
-            tracer?.recordMetrics();
         }
         const ownsClientOutcome = getProxyRequestAccounting(ctx.requestId)?.accountingScope !== "internal";
         if (errorType) {

package/dist/proxy/requestLogger.d.ts

@@ -2,7 +2,7 @@
  * Proxy Request Logger
  * Logs proxy request/response metadata to a rotating log file.
  * Also emits OTLP log records to OpenObserve (or any OTLP-compatible backend)
- * when a LoggerProvider is configured via OpenTelemetry instrumentation.
+ * when OTEL_EXPORTER_OTLP_ENDPOINT configures an OTLP LoggerProvider.
  * Useful for debugging and auditing proxy traffic.
  */
 import type { ProxyBodyCaptureEntry, RequestAttemptLogEntry, RequestLogEntry, ProxyRequestLoggerSnapshot } from "../types/index.js";

package/dist/proxy/requestLogger.js

@@ -2,7 +2,7 @@
  * Proxy Request Logger
  * Logs proxy request/response metadata to a rotating log file.
  * Also emits OTLP log records to OpenObserve (or any OTLP-compatible backend)
- * when a LoggerProvider is configured via OpenTelemetry instrumentation.
+ * when OTEL_EXPORTER_OTLP_ENDPOINT configures an OTLP LoggerProvider.
  * Useful for debugging and auditing proxy traffic.
  */
 import { emitProxyOtelEvent, getProxyOtelLogSnapshot, initializeProxyOtelLogs, isProxyOtelOnly, publishProxyOtelBody, } from "./otelLogSink.js";
@@ -18,9 +18,12 @@ import { writeFile } from "fs/promises";
 import { setImmediate as yieldToRequests } from "node:timers/promises";
 import { captureProxyBody, getBodyCaptureWorkerSnapshot, PROXY_BODY_CAPTURE_DEADLINE_MS, } from "./bodyCaptureWorker.js";
 import { prepareProxyBodyForLogging as prepareRedactedBody, redactProxyHeadersForLogging as redactHeaders, splitUtf8StringByBytes, } from "./bodyCaptureProcessing.js";
+import { trace } from "@opentelemetry/api";
 import { isBorrowedRequest } from "./shareContext.js";
-import { OtelBridge } from "../observability/otelBridge.js";
 import { createRequire } from "node:module";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
 /**
  * Loaded via require() on first actual use rather than a top-level import,
  * so requiring this module (reachable eagerly from dist/server/index.js)
@@ -155,6 +158,7 @@ export async function flushRequestLogs(timeoutMs = REQUEST_LOG_FLUSH_TIMEOUT_MS)
             throw new Error(`Timed out flushing ${remaining} proxy request log operation(s)`);
         }
     }
+    await otlpLoggerProvider?.forceFlush();
 }
 /** @internal Test-only hook for exercising shutdown behavior without real I/O. */
 export const __requestLoggerTestHooks = {
@@ -175,15 +179,8 @@ export const __requestLoggerTestHooks = {
         appendMetadataFile = writeFile;
     },
 };
-/**
- * Lazily-resolved LoggerProvider from OTel instrumentation.
- * null = not resolved yet (will retry), LoggerProvider = resolved, false = permanently unavailable.
- */
-let otelLoggerProvider = null;
-/** Number of times we've tried to resolve the LoggerProvider. */
-let otelResolveAttempts = 0;
-/** Max number of resolve attempts before giving up. */
-const MAX_RESOLVE_ATTEMPTS = 10;
+let otlpLoggerProvider;
+let otlpLoggerInitialized = false;
 const BODY_OTLP_CHUNK_SIZE = 16_000;
 /**
  * Initialize private request logs and preserve required lifecycle admission on startup failures.
@@ -365,45 +362,43 @@ export async function logRequestAttempt(entry) {
         // Non-fatal — don't crash proxy for logging failures
     }
 }
-/**
- * Lazily resolve the LoggerProvider from OTel instrumentation.
- * Uses dynamic import to avoid hard dependency — if instrumentation.ts
- * hasn't been loaded or OTLP is not configured, this is a no-op.
- * Retries up to MAX_RESOLVE_ATTEMPTS times to handle race conditions
- * where OTel initialization completes after the first log request.
- */
-async function resolveLoggerProvider() {
-    if (isProxyOtelOnly()) {
-        return initializeProxyOtelLogs();
-    }
-    if (otelLoggerProvider === false) {
+function createOtlpLoggerProvider() {
+    const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    if (!endpoint) {
         return undefined;
-    } // permanently unavailable
-    if (otelLoggerProvider !== null) {
-        return otelLoggerProvider;
     }
-    // Not resolved yet — try to resolve
-    otelResolveAttempts++;
     try {
-        const { getLoggerProvider } = await import("../services/server/ai/observability/instrumentation.js");
-        const provider = getLoggerProvider();
-        if (provider) {
-            otelLoggerProvider = provider;
-            return provider;
-        }
-        // Provider not available yet — if we've exceeded max attempts, give up
-        if (otelResolveAttempts >= MAX_RESOLVE_ATTEMPTS) {
-            otelLoggerProvider = false; // permanently unavailable
-        }
-        // Otherwise leave as null so we retry next time
-        return undefined;
+        return new LoggerProvider({
+            resource: resourceFromAttributes({
+                "service.name": process.env.OTEL_SERVICE_NAME || "neurolink",
+            }),
+            processors: [
+                new BatchLogRecordProcessor(new OTLPLogExporter({ url: `${endpoint}/v1/logs` }), {
+                    maxQueueSize: 2048,
+                    maxExportBatchSize: 64,
+                    scheduledDelayMillis: 2000,
+                    exportTimeoutMillis: 30000,
+                }),
+            ],
+        });
     }
-    catch {
-        // instrumentation.ts not available (e.g. standalone mode) — disable permanently
-        otelLoggerProvider = false;
+    catch (error) {
+        logger.warn("[RequestLogger] Failed to create OTLP log exporter", {
+            error: error instanceof Error ? error.message : String(error),
+        });
         return undefined;
     }
 }
+async function resolveLoggerProvider() {
+    if (isProxyOtelOnly()) {
+        return initializeProxyOtelLogs();
+    }
+    if (!otlpLoggerInitialized) {
+        otlpLoggerInitialized = true;
+        otlpLoggerProvider = createOtlpLoggerProvider();
+    }
+    return otlpLoggerProvider;
+}
 /**
  * Emit a RequestLogEntry as an OTLP log record.
  * Non-blocking, non-fatal — failures are silently swallowed.
@@ -837,8 +832,7 @@ export async function logStreamError(entry) {
     if (!logEnabled || (!logDir && !isProxyOtelOnly())) {
         return;
     }
-    const bridge = new OtelBridge();
-    const traceCtx = bridge.getCurrentTraceContext();
+    const traceCtx = trace.getActiveSpan()?.spanContext();
     const logEntry = {
         ...entry,
         responseStatus: 200,

package/dist/server/middleware/common.js

@@ -20,7 +20,7 @@ export function createTimingMiddleware() {
         name: "timing",
         order: 0, // Run first
         handler: async (ctx, next) => {
-            return tracers.middleware.startActiveSpan("neurolink.middleware.timing", async (otelSpan) => {
+            return tracers.middleware.startActiveSpan("middleware.timing", async (otelSpan) => {
                 try {
                     const startTime = Date.now();
                     const startHrTime = process.hrtime.bigint();

package/dist/server/routes/agentRoutes.js

@@ -74,7 +74,7 @@ export function createAgentRoutes(basePath = "/api") {
                     }
                     const request = validation.data;
                     return withSpan({
-                        name: "neurolink.http.execute",
+                        name: "http.execute",
                         tracer: tracers.http,
                         attributes: {
                             "http.route": "/api/agent/execute",
@@ -165,7 +165,7 @@ export function createAgentRoutes(basePath = "/api") {
                     // Wrap stream with a span that stays open for the full consumption
                     // lifetime, not just the generator creation.
                     async function* redactedStream() {
-                        const streamSpan = tracers.http.startSpan("neurolink.http.stream", {
+                        const streamSpan = tracers.http.startSpan("http.stream", {
                             attributes: {
                                 "http.route": "/api/agent/stream",
                                 "ai.provider": request.provider || "default",
@@ -221,7 +221,7 @@ export function createAgentRoutes(basePath = "/api") {
                     try {
                         const providerName = request.provider || "openai";
                         return await withSpan({
-                            name: "neurolink.http.embed",
+                            name: "http.embed",
                             tracer: tracers.http,
                             attributes: {
                                 "http.route": "/api/agent/embed",
@@ -260,7 +260,7 @@ export function createAgentRoutes(basePath = "/api") {
                     try {
                         const providerName = request.provider || "openai";
                         return await withSpan({
-                            name: "neurolink.http.embedMany",
+                            name: "http.embedMany",
                             tracer: tracers.http,
                             attributes: {
                                 "http.route": "/api/agent/embed-many",