neatlogs 1.1.17 → 1.1.18

package/dist/index.cjs

@@ -4549,6 +4549,7 @@ var NeatlogsSpanProcessor = class {
   unifiedProcessor;
   perfStats;
   _retrieversToSuppress;
+  _activeSpans;
   // File logging
   _logRawSpansEnabled;
   _logProcessedSpansEnabled;
@@ -4574,6 +4575,7 @@ var NeatlogsSpanProcessor = class {
       spansExported: 0
     };
     this._retrieversToSuppress = /* @__PURE__ */ new Set();
+    this._activeSpans = /* @__PURE__ */ new Map();
   }
   // ── File logging init ─────────────────────────────────
   _initFileLogging() {
@@ -4606,6 +4608,10 @@ var NeatlogsSpanProcessor = class {
   onStart(span2, parentContext) {
     const startTime = import_node_perf_hooks.performance.now();
     try {
+      const scopeName = span2.instrumentationLibrary?.name ?? "";
+      if (scopeName.startsWith("neatlogs") || span2.parentSpanId !== void 0 && this._activeSpans.has(span2.parentSpanId)) {
+        this._activeSpans.set(span2.spanContext().spanId, span2);
+      }
       if (!span2.parentSpanId) {
         applySessionAttributes(span2, void 0, true);
         applyEndUserAttributes(span2, void 0, void 0, true);
@@ -4682,6 +4688,7 @@ var NeatlogsSpanProcessor = class {
   }
   // ── SpanProcessor.onEnd ───────────────────────────────
   onEnd(span2) {
+    this._activeSpans.delete(span2.spanContext().spanId);
     if (span2.name === "neatlogs.trace.complete") {
       return;
     }
@@ -4860,6 +4867,47 @@ var NeatlogsSpanProcessor = class {
       this.perfStats.onEndTime += import_node_perf_hooks.performance.now() - startTime;
     }
   }
+  /**
+   * End active Neatlogs-owned spans child-first before provider shutdown.
+   * Ending the actual root through the normal lifecycle emits the completion
+   * marker; interruption attributes keep the termination explicit.
+   */
+  endActiveSpans(reason = "shutdown") {
+    const activeById = this._activeSpans;
+    this._activeSpans = /* @__PURE__ */ new Map();
+    const active = [...activeById.values()];
+    if (active.length === 0) return 0;
+    const activeIds = new Set(active.map((span2) => span2.spanContext().spanId));
+    const depth = (span2) => {
+      let current = span2;
+      const seen = /* @__PURE__ */ new Set();
+      let value = 0;
+      while (current?.parentSpanId && activeIds.has(current.parentSpanId)) {
+        const parentId = current.parentSpanId;
+        if (seen.has(parentId)) break;
+        seen.add(parentId);
+        value += 1;
+        current = activeById.get(parentId);
+      }
+      return value;
+    };
+    const cleanReason = String(reason || "shutdown").slice(0, 256);
+    let ended = 0;
+    for (const span2 of active.sort((a, b) => depth(b) - depth(a))) {
+      try {
+        if (!span2.isRecording()) continue;
+        span2.setAttribute("neatlogs.trace.interrupted", true);
+        span2.setAttribute("neatlogs.trace.termination.reason", cleanReason);
+        span2.end();
+        ended += 1;
+      } catch (error) {
+        logger10.warn(
+          `Failed to end active span during ${cleanReason}: ${error}`
+        );
+      }
+    }
+    return ended;
+  }
   // ── Completion marker ─────────────────────────────────
   _emitCompletionMarker(rootSpan, traceId, resourceAttrs) {
     try {
@@ -6106,7 +6154,7 @@ function _resetMastraCache() {
 }
 
 // src/version.ts
-var __version__ = "1.1.17";
+var __version__ = "1.1.18";
 
 // src/init.ts
 var logger13 = getLogger();
@@ -6118,8 +6166,24 @@ var _spanProcessor = null;
 var _debugMode2 = false;
 var _instrumentationManager = null;
 var _sigHandlersRegistered = false;
-var _shutdownOnSignal = () => {
-  shutdown().catch(() => {
+var _signalShutdownStarted = false;
+var _shutdownPromise = null;
+var _shutdownBeforeExit = () => {
+  void shutdown("beforeExit").catch((error) => {
+    logger13.error(`Error shutting down before exit: ${error}`);
+  });
+};
+var _shutdownOnSignal = (signal) => {
+  if (_signalShutdownStarted) return;
+  _signalShutdownStarted = true;
+  void shutdown(signal).catch((error) => {
+    logger13.error(`Error shutting down after ${signal}: ${error}`);
+  }).finally(() => {
+    try {
+      process.kill(process.pid, signal);
+    } catch {
+      process.exitCode = signal === "SIGINT" ? 130 : 143;
+    }
   });
 };
 function _resolveWorkflowName(workflowName) {
@@ -6284,7 +6348,7 @@ async function init(options = {}) {
   }
   const registerShutdownHandlers = options.registerShutdownHandlers ?? _ownsTracerProvider;
   if (registerShutdownHandlers && !_sigHandlersRegistered) {
-    process.on("beforeExit", _shutdownOnSignal);
+    process.on("beforeExit", _shutdownBeforeExit);
     process.on("SIGTERM", _shutdownOnSignal);
     process.on("SIGINT", _shutdownOnSignal);
     _sigHandlersRegistered = true;
@@ -6326,14 +6390,32 @@ async function flush() {
   }
   return success;
 }
-async function shutdown() {
+function shutdown(terminationReason = "shutdown") {
+  if (_shutdownPromise) return _shutdownPromise;
+  const currentShutdown = _performShutdown(terminationReason);
+  _shutdownPromise = currentShutdown;
+  const clearCurrentShutdown = () => {
+    if (_shutdownPromise === currentShutdown) _shutdownPromise = null;
+  };
+  void currentShutdown.then(clearCurrentShutdown, clearCurrentShutdown);
+  return currentShutdown;
+}
+async function _performShutdown(terminationReason) {
   if (_sigHandlersRegistered) {
-    process.removeListener("beforeExit", _shutdownOnSignal);
+    process.removeListener("beforeExit", _shutdownBeforeExit);
     process.removeListener("SIGTERM", _shutdownOnSignal);
     process.removeListener("SIGINT", _shutdownOnSignal);
     _sigHandlersRegistered = false;
   }
   let success = true;
+  if (_spanProcessor) {
+    const ended = _spanProcessor.endActiveSpans(terminationReason);
+    if (ended > 0) {
+      logger13.info(
+        `Ended ${ended} active Neatlogs span(s) during ${terminationReason}`
+      );
+    }
+  }
   _instrumentationManager?.disable();
   _instrumentationManager = null;
   _resetMastraCache();
@@ -6372,6 +6454,7 @@ async function shutdown() {
   _logProvider = null;
   _spanProcessor = null;
   _debugMode2 = false;
+  _signalShutdownStarted = false;
   _setSessionConfig({});
   logger13.info("Neatlogs SDK shutdown complete");
   return success;
@@ -7030,29 +7113,25 @@ function tracedResponsesCreate(original) {
   return function(opts, ...rest) {
     const tracer = getProviderTracer(TRACER_NAME3);
     const model = opts?.model ?? "";
+    const isStream = opts?.stream === true;
     const span2 = tracer.startSpan("openai.responses.create", {
       attributes: {
         "neatlogs.span.kind": "LLM",
         "neatlogs.llm.provider": "openai",
         "neatlogs.llm.system": "openai",
         "neatlogs.llm.model_name": model,
+        "neatlogs.llm.is_streaming": isStream,
         "input.value": safeStringify3(opts?.input ?? "")
       }
     }, getNeatlogsParentContext());
+    setInvocationParams(span2, opts);
     const promise = withNeatlogsSpan(span2, () => original(opts, ...rest));
     return promise.then(
       (response) => {
-        if (response?.output_text) {
-          span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
-          span2.setAttribute("neatlogs.llm.output_messages.0.content", response.output_text);
-        }
-        if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
-        if (response?.usage) {
-          if (response.usage.input_tokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", response.usage.input_tokens);
-          if (response.usage.output_tokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", response.usage.output_tokens);
+        if (isStream) {
+          return wrapResponsesAsyncIterableStream(response, span2);
         }
-        span2.setStatus({ code: import_api10.SpanStatusCode.OK });
-        span2.end();
+        finalizeResponsesResponse(span2, response);
         return response;
       },
       (err) => {
@@ -7062,6 +7141,110 @@ function tracedResponsesCreate(original) {
     );
   };
 }
+function wrapResponsesAsyncIterableStream(stream, span2) {
+  const originalAsyncIterator = stream?.[Symbol.asyncIterator]?.bind(stream);
+  if (!originalAsyncIterator) {
+    finalizeResponsesResponse(span2, stream);
+    return stream;
+  }
+  const textParts = [];
+  let completedResponse;
+  let finalized = false;
+  const finalize = () => {
+    if (finalized) return;
+    finalized = true;
+    finalizeResponsesResponse(span2, completedResponse, textParts.join(""));
+  };
+  return new Proxy(stream, {
+    get(target, prop) {
+      if (prop === Symbol.asyncIterator) {
+        return () => {
+          const iterator = originalAsyncIterator();
+          return {
+            async next() {
+              try {
+                const result = await iterator.next();
+                if (result.done) {
+                  finalize();
+                  return result;
+                }
+                const event = result.value;
+                if (event?.type === "response.output_text.delta" && typeof event.delta === "string") {
+                  textParts.push(event.delta);
+                } else if (event?.type === "response.completed") {
+                  completedResponse = event.response;
+                }
+                return result;
+              } catch (err) {
+                if (!finalized) {
+                  finalized = true;
+                  recordError(span2, err);
+                }
+                throw err;
+              }
+            },
+            async return(value2) {
+              try {
+                return await (iterator.return?.(value2) ?? { done: true, value: value2 });
+              } finally {
+                finalize();
+              }
+            },
+            async throw(err) {
+              if (!finalized) {
+                finalized = true;
+                recordError(span2, err);
+              }
+              if (iterator.throw) return iterator.throw(err);
+              throw err;
+            }
+          };
+        };
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function finalizeResponsesResponse(span2, response, streamedText = "") {
+  const text = response?.output_text || streamedText || extractResponsesOutputText(response?.output);
+  if (text) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", text);
+    span2.setAttribute("output.value", text);
+  } else if (response?.output) {
+    span2.setAttribute("output.value", safeStringify3(response.output));
+  }
+  if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
+  if (response?.status) span2.setAttribute("neatlogs.llm.finish_reason", response.status);
+  const usage = response?.usage;
+  if (usage) {
+    if (usage.input_tokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", usage.input_tokens);
+    if (usage.output_tokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", usage.output_tokens);
+    if (usage.total_tokens != null) span2.setAttribute("neatlogs.llm.token_count.total", usage.total_tokens);
+    if (usage.input_tokens_details?.cached_tokens != null) {
+      span2.setAttribute("neatlogs.llm.token_count.cache_read", usage.input_tokens_details.cached_tokens);
+    }
+    if (usage.output_tokens_details?.reasoning_tokens != null) {
+      span2.setAttribute("neatlogs.llm.token_count.reasoning", usage.output_tokens_details.reasoning_tokens);
+    }
+  }
+  span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+  span2.end();
+}
+function extractResponsesOutputText(output) {
+  if (!Array.isArray(output)) return "";
+  const parts = [];
+  for (const item of output) {
+    if (item?.type !== "message" || !Array.isArray(item.content)) continue;
+    for (const content of item.content) {
+      if (content?.type === "output_text" && typeof content.text === "string") {
+        parts.push(content.text);
+      }
+    }
+  }
+  return parts.join("");
+}
 function wrapAsyncIterableStream(stream, span2) {
   const chunks = [];
   const originalAsyncIterator = stream[Symbol.asyncIterator]?.bind(stream);