neatlogs 1.1.21 → 1.1.22

package/dist/index.cjs

@@ -8494,16 +8494,20 @@ var ObservableBatchLogRecordProcessor = class extends import_sdk_logs.BatchLogRe
 // src/core/log.ts
 var import_node_async_hooks5 = require("async_hooks");
 var logger12 = getLogger();
-var _otelLogger = null;
-var _debugMode = false;
+var LOG_RUNTIME_STATE_KEY = /* @__PURE__ */ Symbol.for("neatlogs.log_runtime_state");
+var neatlogsGlobal3 = globalThis;
+var logRuntimeState = neatlogsGlobal3[LOG_RUNTIME_STATE_KEY] ?? (neatlogsGlobal3[LOG_RUNTIME_STATE_KEY] = {
+  otelLogger: null,
+  debugMode: false
+});
 var stdoutCaptureContext = new import_node_async_hooks5.AsyncLocalStorage();
 function resolveOtelLogger() {
   const client = getActiveClient();
-  return client ? client.getLogger() : _otelLogger;
+  return client ? client.getLogger() : logRuntimeState.otelLogger;
 }
 function _setOtelLogger(otelLogger, debug) {
-  _otelLogger = otelLogger;
-  _debugMode = debug;
+  logRuntimeState.otelLogger = otelLogger;
+  logRuntimeState.debugMode = debug;
 }
 function log(msgTemplate, options) {
   const { level = "info", ...variables } = options ?? {};
@@ -8511,7 +8515,7 @@ function log(msgTemplate, options) {
   for (const [key, value] of Object.entries(variables)) {
     rendered = rendered.replace(new RegExp(`\\{${key}\\}`, "g"), String(value));
   }
-  if (_debugMode) {
+  if (logRuntimeState.debugMode) {
     console.log(`[neatlogs:log] ${rendered}`);
   }
   const otelLogger = resolveOtelLogger();
@@ -9376,7 +9380,7 @@ function _resetMastraCache() {
 }
 
 // src/version.ts
-var __version__ = "1.1.21";
+var __version__ = "1.1.22";
 
 // src/core/deadline.ts
 async function runByDeadline(operation, deadlineMs) {
@@ -9412,7 +9416,7 @@ var _logProvider = null;
 var _spanProcessor = null;
 var _transportSpanProcessors = [];
 var _completionProcessor = null;
-var _debugMode2 = false;
+var _debugMode = false;
 var _deliveryDiagnostics = new DeliveryDiagnostics();
 var _initIdentity = null;
 var _effectiveSampleRate = 1;
@@ -9704,7 +9708,7 @@ async function _performInit(options) {
   if (options.debug) {
     enableDebugLogging();
   }
-  _debugMode2 = options.debug ?? false;
+  _debugMode = options.debug ?? false;
   const resolvedWorkflowName = _resolveWorkflowName(options.workflowName);
   const endpoint = resolveInitEndpoint(options.endpoint);
   const baseUrl = resolveIngestBaseUrl(endpoint);
@@ -10090,7 +10094,7 @@ async function _performShutdown(terminationReason, timeoutMs) {
   _spanProcessor = null;
   _transportSpanProcessors = [];
   _completionProcessor = null;
-  _debugMode2 = false;
+  _debugMode = false;
   _effectiveSampleRate = 1;
   _exportEnabled = false;
   _queueMaxSize = 2048;
@@ -10102,7 +10106,7 @@ async function _performShutdown(terminationReason, timeoutMs) {
   return success;
 }
 function isDebugEnabled() {
-  return _debugMode2;
+  return _debugMode;
 }
 function _doctorRuntimeSnapshot() {
   return {
@@ -10682,10 +10686,104 @@ function setHeader(carrier, name, value) {
 // src/ai-sdk.ts
 var import_api13 = require("@opentelemetry/api");
 var TRACER_NAME2 = "neatlogs.ai-sdk";
+var NEATLOGS_V7_INTEGRATION = /* @__PURE__ */ Symbol("neatlogs.ai-sdk.v7-integration");
+var LazyV7OpenTelemetryIntegration = class {
+  constructor(tracer, metadata) {
+    this.tracer = tracer;
+    this.metadata = metadata;
+  }
+  tracer;
+  metadata;
+  [NEATLOGS_V7_INTEGRATION] = true;
+  delegatePromise;
+  getDelegate() {
+    return this.delegatePromise ??= import("@ai-sdk/otel").then(
+      ({ OpenTelemetry }) => new OpenTelemetry({
+        tracer: this.tracer,
+        enrichSpan: () => this.metadata
+      })
+    ).catch((error) => {
+      const detail = error instanceof Error ? `: ${error.message}` : "";
+      throw new Error(
+        "Vercel AI SDK v7 telemetry requires the optional @ai-sdk/otel peer dependency" + detail
+      );
+    });
+  }
+  async notify(method, event) {
+    const delegate = await this.getDelegate();
+    const fn = delegate[method];
+    if (typeof fn === "function") {
+      await Reflect.apply(fn, delegate, [event]);
+    }
+  }
+  onStart(event) {
+    return this.notify("onStart", event);
+  }
+  onStepStart(event) {
+    return this.notify("onStepStart", event);
+  }
+  onLanguageModelCallStart(event) {
+    return this.notify("onLanguageModelCallStart", event);
+  }
+  onLanguageModelCallEnd(event) {
+    return this.notify("onLanguageModelCallEnd", event);
+  }
+  onToolExecutionStart(event) {
+    return this.notify("onToolExecutionStart", event);
+  }
+  onToolExecutionEnd(event) {
+    return this.notify("onToolExecutionEnd", event);
+  }
+  onStepEnd(event) {
+    return this.notify("onStepEnd", event);
+  }
+  onStepFinish(event) {
+    return this.notify("onStepFinish", event);
+  }
+  onObjectStepStart(event) {
+    return this.notify("onObjectStepStart", event);
+  }
+  onObjectStepEnd(event) {
+    return this.notify("onObjectStepEnd", event);
+  }
+  onEmbedStart(event) {
+    return this.notify("onEmbedStart", event);
+  }
+  onEmbedEnd(event) {
+    return this.notify("onEmbedEnd", event);
+  }
+  onRerankStart(event) {
+    return this.notify("onRerankStart", event);
+  }
+  onRerankEnd(event) {
+    return this.notify("onRerankEnd", event);
+  }
+  onEnd(event) {
+    return this.notify("onEnd", event);
+  }
+  onAbort(event) {
+    return this.notify("onAbort", event);
+  }
+  onError(event) {
+    return this.notify("onError", event);
+  }
+  async executeLanguageModelCall(options) {
+    const delegate = await this.getDelegate();
+    const fn = delegate.executeLanguageModelCall;
+    return typeof fn === "function" ? Reflect.apply(fn, delegate, [options]) : options.execute();
+  }
+  async executeTool(options) {
+    const delegate = await this.getDelegate();
+    const fn = delegate.executeTool;
+    return typeof fn === "function" ? Reflect.apply(fn, delegate, [options]) : options.execute();
+  }
+};
 function createAITelemetry(opts = {}) {
   const userMeta = opts.metadata ?? {};
   const neatlogsTracer = getRoutingNeatlogsTracer(TRACER_NAME2);
   const callerTracer = opts.tracer;
+  const tracer = callerTracer ? createMirroredTracer(callerTracer, neatlogsTracer) : neatlogsTracer;
+  const metadata = callerTracer ? { ...userMeta } : { ...userMeta, neatlogsWrapped: true };
   return {
     isEnabled: true,
     recordInputs: true,
@@ -10694,11 +10792,12 @@ function createAITelemetry(opts = {}) {
     // internally, which would otherwise parent its native spans from the foreign
     // global context AND push them onto it (so a co-tenant's next span inherits
     // ours). The facade routes both through the private Neatlogs context.
-    tracer: callerTracer ? createMirroredTracer(callerTracer, neatlogsTracer) : neatlogsTracer,
+    tracer,
     ...opts.functionId !== void 0 ? { functionId: opts.functionId } : {},
     // The marker is an implementation detail used only when Neatlogs owns the
     // telemetry stream. Do not leak it into caller-owned providers.
-    metadata: callerTracer ? { ...userMeta } : { ...userMeta, neatlogsWrapped: true }
+    metadata,
+    integrations: [new LazyV7OpenTelemetryIntegration(tracer, metadata)]
   };
 }
 function safeStringify2(value) {
@@ -10731,7 +10830,7 @@ function setOutputValue(span2, result) {
         span2.setAttribute("output.value", text);
       }
       if (r.finishReason) {
-        span2.setAttribute("gen_ai.finish_reason", String(r.finishReason));
+        span2.setAttribute("neatlogs.llm.finish_reason", String(r.finishReason));
       }
       return;
     }
@@ -10740,7 +10839,7 @@ function setOutputValue(span2, result) {
         span2.setAttribute("output.value", safeStringify2(r.object));
       }
       if (r.finishReason) {
-        span2.setAttribute("gen_ai.finish_reason", String(r.finishReason));
+        span2.setAttribute("neatlogs.llm.finish_reason", String(r.finishReason));
       }
       return;
     }
@@ -10760,7 +10859,7 @@ function setStreamOutputValue(span2, event) {
     if (stringified) span2.setAttribute("output.value", stringified);
   }
   if (e.finishReason) {
-    span2.setAttribute("gen_ai.finish_reason", String(e.finishReason));
+    span2.setAttribute("neatlogs.llm.finish_reason", String(e.finishReason));
   }
 }
 var WRAPPED_FUNCTIONS = [
@@ -10780,6 +10879,8 @@ var wrappedExports = /* @__PURE__ */ new WeakSet();
 var wrapperByOriginal = /* @__PURE__ */ new WeakMap();
 function wrapAISDK(aiModule) {
   const wrapped = { ...aiModule };
+  const hasRegisterTelemetry = "registerTelemetry" in aiModule && typeof Reflect.get(aiModule, "registerTelemetry") === "function";
+  const telemetryKey = hasRegisterTelemetry ? "telemetry" : "experimental_telemetry";
   for (const name of WRAPPED_FUNCTIONS) {
     const original = aiModule[name];
     if (typeof original !== "function") continue;
@@ -10791,12 +10892,16 @@ function wrapAISDK(aiModule) {
     if (name === "streamText" || name === "streamObject") {
       wrapped[name] = cacheWrapper(
         original,
-        createStreamWrapper(name, original)
+        createStreamWrapper(name, original, telemetryKey)
       );
     } else {
       wrapped[name] = cacheWrapper(
         original,
-        createAsyncWrapper(name, original)
+        createAsyncWrapper(
+          name,
+          original,
+          telemetryKey
+        )
       );
     }
   }
@@ -10806,7 +10911,7 @@ function wrapAISDK(aiModule) {
     const existing = getExistingWrapper(original);
     wrapped[name] = existing ?? cacheWrapper(
       original,
-      createAgentConstructorWrapper(original)
+      createAgentConstructorWrapper(original, telemetryKey)
     );
   }
   return wrapped;
@@ -10820,26 +10925,30 @@ function cacheWrapper(original, wrapped) {
   wrappedExports.add(wrapped);
   return wrapped;
 }
-function createAgentConstructorWrapper(original) {
+function createAgentConstructorWrapper(original, telemetryKey) {
   return new Proxy(original, {
     construct(target, args, newTarget) {
       if (args.length === 0 || typeof args[0] !== "object" || args[0] === null) {
         return Reflect.construct(target, args, newTarget);
       }
-      const settings = mergeAgentSettings(args[0]);
+      const settings = mergeAgentSettings(args[0], telemetryKey);
       return Reflect.construct(target, [settings, ...args.slice(1)], newTarget);
     }
   });
 }
-function mergeAgentSettings(settings) {
-  const merged = mergeTelemetry(settings);
+function mergeAgentSettings(settings, telemetryKey) {
+  const merged = mergeTelemetry(settings, telemetryKey);
   const userPrepareCall = settings.prepareCall;
   if (typeof userPrepareCall !== "function") return merged;
   return {
     ...merged,
     prepareCall: async function wrappedPrepareCall(...args) {
       const prepared = await Reflect.apply(userPrepareCall, this, args);
-      return prepared == null ? prepared : mergeTelemetry(prepared, settings.experimental_telemetry);
+      return prepared == null ? prepared : mergeTelemetry(
+        prepared,
+        telemetryKey,
+        settings.telemetry ?? settings.experimental_telemetry
+      );
     }
   };
 }
@@ -10851,7 +10960,7 @@ function rootSpanKind(name) {
 function getParentContext() {
   return getNeatlogsParentContext();
 }
-function createAsyncWrapper(name, original) {
+function createAsyncWrapper(name, original, telemetryKey) {
   return async function wrappedAsyncFn(opts) {
     const tracer = getNeatlogsTracer(TRACER_NAME2);
     const parentContext = getParentContext();
@@ -10871,7 +10980,7 @@ function createAsyncWrapper(name, original) {
           if (name === "rerank" && opts?.query) {
             span2.setAttribute("ai.rerank.query", String(opts.query));
           }
-          const merged = mergeTelemetry(opts);
+          const merged = mergeTelemetry(opts, telemetryKey);
           const result = await original(merged);
           if (!isEmbedOrRerank) {
             setOutputValue(span2, result);
@@ -10888,7 +10997,7 @@ function createAsyncWrapper(name, original) {
     );
   };
 }
-function createStreamWrapper(name, original) {
+function createStreamWrapper(name, original, telemetryKey) {
   return function wrappedStreamFn(opts) {
     const tracer = getNeatlogsTracer(TRACER_NAME2);
     const parentContext = getParentContext();
@@ -10908,7 +11017,7 @@ function createStreamWrapper(name, original) {
         };
         try {
           setInputValue(span2, opts);
-          const merged = mergeTelemetry(opts);
+          const merged = mergeTelemetry(opts, telemetryKey);
           const userOnFinish = opts?.onFinish;
           const userOnError = opts?.onError;
           const wrappedOpts = {
@@ -11033,25 +11142,47 @@ function createMirroredTracer(primary, secondary) {
     })
   };
 }
-function mergeTelemetry(opts, fallbackTelemetry) {
+function isNeatlogsV7Integration(integration) {
+  return typeof integration === "object" && integration !== null && NEATLOGS_V7_INTEGRATION in integration;
+}
+function mergeTelemetry(opts, telemetryKey, fallbackTelemetry) {
+  const legacyTelemetry = opts?.experimental_telemetry ?? {};
+  const v7Telemetry = opts?.telemetry ?? {};
+  const preferredTelemetry = telemetryKey === "telemetry" ? { ...legacyTelemetry, ...v7Telemetry } : { ...v7Telemetry, ...legacyTelemetry };
   const requestedTelemetry = {
     ...fallbackTelemetry,
-    ...opts?.experimental_telemetry,
+    ...preferredTelemetry,
     metadata: {
       ...fallbackTelemetry?.metadata,
-      ...opts?.experimental_telemetry?.metadata
+      ...legacyTelemetry.metadata,
+      ...v7Telemetry.metadata
     }
   };
-  const baseTelemetry = createAITelemetry({
+  const existingNeatlogsIntegration = Array.isArray(
+    requestedTelemetry.integrations
+  ) ? requestedTelemetry.integrations.find(isNeatlogsV7Integration) : void 0;
+  const baseTelemetry = existingNeatlogsIntegration ? {
+    isEnabled: true,
+    recordInputs: true,
+    recordOutputs: true,
+    tracer: requestedTelemetry.tracer,
+    ...requestedTelemetry.functionId !== void 0 ? { functionId: requestedTelemetry.functionId } : {},
+    metadata: requestedTelemetry.metadata,
+    integrations: [existingNeatlogsIntegration]
+  } : createAITelemetry({
     functionId: requestedTelemetry.functionId,
     metadata: requestedTelemetry.metadata,
     tracer: requestedTelemetry.tracer
   });
   const callerTracer = requestedTelemetry.tracer;
   const hasCallerTracer = callerTracer !== void 0;
+  const requestedIntegrations = Array.isArray(requestedTelemetry.integrations) ? requestedTelemetry.integrations.filter(
+    (integration) => !isNeatlogsV7Integration(integration)
+  ) : [];
+  const { telemetry: _telemetry, experimental_telemetry: _legacy, ...rest } = opts ?? {};
   return {
-    ...opts,
-    experimental_telemetry: {
+    ...rest,
+    [telemetryKey]: {
       ...baseTelemetry,
       ...requestedTelemetry,
       isEnabled: true,
@@ -11061,7 +11192,8 @@ function mergeTelemetry(opts, fallbackTelemetry) {
       // Do not add Neatlogs-only marker metadata to a caller-owned telemetry
       // pipeline such as Laminar. Both providers receive the same AI SDK span
       // data, while their providers, parent contexts, and exporters stay separate.
-      metadata: hasCallerTracer ? requestedTelemetry.metadata : baseTelemetry.metadata
+      metadata: hasCallerTracer ? requestedTelemetry.metadata : baseTelemetry.metadata,
+      integrations: [...baseTelemetry.integrations, ...requestedIntegrations]
     }
   };
 }