neatlogs 1.1.0 → 1.1.2

package/dist/index.mjs

@@ -1,6 +1,5 @@
 // src/init.ts
-import { randomBytes as randomBytes2 } from "crypto";
-import * as path3 from "path";
+import * as path2 from "path";
 import { metrics } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
 import { Resource } from "@opentelemetry/resources";
@@ -9,7 +8,7 @@ import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
 import { MeterProvider } from "@opentelemetry/sdk-metrics";
-import { LoggerProvider, SimpleLogRecordProcessor, BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { LoggerProvider, BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
 
 // src/core/span-processor.ts
@@ -2300,6 +2299,31 @@ import {
 
 // src/core/end-user.ts
 import { trace as otelTrace, context as otelContext } from "@opentelemetry/api";
+
+// src/core/identity.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var _GLOBAL_KEY = /* @__PURE__ */ Symbol.for("neatlogs.identity.storage");
+var _g = globalThis;
+var _storage = _g[_GLOBAL_KEY] ?? (_g[_GLOBAL_KEY] = new AsyncLocalStorage2());
+function currentSessionId() {
+  return _storage.getStore()?.sessionId;
+}
+function currentEndUserId() {
+  return _storage.getStore()?.endUserId;
+}
+function currentEndUserMetadata() {
+  return _storage.getStore()?.endUserMetadata;
+}
+function identify(opts, fn) {
+  const prev = _storage.getStore();
+  const next = { ...prev ?? {} };
+  if (opts.sessionId !== void 0) next.sessionId = opts.sessionId;
+  if (opts.endUserId !== void 0) next.endUserId = opts.endUserId;
+  if (opts.endUserMetadata !== void 0) next.endUserMetadata = opts.endUserMetadata;
+  return _storage.run(next, fn);
+}
+
+// src/core/end-user.ts
 var logger4 = getLogger();
 var END_USER_ID_KEY = "neatlogs.end_user.id";
 var END_USER_METADATA_KEY = "neatlogs.end_user.metadata";
@@ -2317,25 +2341,42 @@ function isRootSpan() {
   return !(current && current.isRecording());
 }
 function applyEndUserAttributes(span2, endUserId, endUserMetadata, isRoot = true) {
-  if (!endUserId && !endUserMetadata) return;
+  const resolvedId = isRoot ? endUserId ?? currentEndUserId() : endUserId;
+  const resolvedMeta = isRoot ? endUserMetadata ?? currentEndUserMetadata() : endUserMetadata;
+  if (!resolvedId && !resolvedMeta) return;
   if (!isRoot) {
     logger4.debug(
-      "[end_user] Ignoring endUserId/endUserMetadata on a non-root span \u2014 declare it on the trace root (top-level trace()/span()) or init()."
+      "[end_user] Ignoring endUserId/endUserMetadata on a non-root span \u2014 declare it on the trace root (top-level trace()/span()) or identify()."
     );
     return;
   }
-  if (endUserId) {
-    span2.setAttribute(END_USER_ID_KEY, String(endUserId));
+  if (resolvedId) {
+    span2.setAttribute(END_USER_ID_KEY, String(resolvedId));
   }
-  const metaJson = normalizeEndUserMetadata(endUserMetadata);
+  const metaJson = normalizeEndUserMetadata(resolvedMeta);
   if (metaJson) {
     span2.setAttribute(END_USER_METADATA_KEY, metaJson);
   }
 }
 
+// src/core/session.ts
+var logger5 = getLogger();
+var SESSION_ID_KEY = "neatlogs.session.id";
+function applySessionAttributes(span2, sessionId, isRoot = true) {
+  const resolved = isRoot ? sessionId ?? currentSessionId() : sessionId;
+  if (!resolved) return;
+  if (!isRoot) {
+    logger5.debug(
+      "[session] Ignoring sessionId on a non-root span \u2014 declare it on the trace root (top-level trace()/span()) or identify()."
+    );
+    return;
+  }
+  span2.setAttribute(SESSION_ID_KEY, String(resolved));
+}
+
 // src/decorators/base.ts
 import { trace, SpanStatusCode } from "@opentelemetry/api";
-var logger5 = getLogger();
+var logger6 = getLogger();
 var TRACER_NAME = "neatlogs";
 function safeJsonDumps(value) {
   try {
@@ -2394,13 +2435,14 @@ function decorateSpan(opts, fn) {
     return tracer.startActiveSpan(spanName, (span2) => {
       try {
         setCommonSpanAttrs(span2, opts);
+        applySessionAttributes(span2, opts.sessionId, isRoot);
         applyEndUserAttributes(span2, opts.endUserId, opts.endUserMetadata, isRoot);
         if (captureInput && doCapture && args.length > 0) {
           try {
             const inputValue = args.length === 1 ? serializeObj(args[0]) : args.map(serializeObj);
             span2.setAttribute("input.value", safeJsonDumps(inputValue));
           } catch (err) {
-            logger5.debug(`Failed to capture input: ${err}`);
+            logger6.debug(`Failed to capture input: ${err}`);
           }
         }
         const result = fn(...args);
@@ -2410,7 +2452,7 @@ function decorateSpan(opts, fn) {
               try {
                 span2.setAttribute("output.value", safeJsonDumps(serializeObj(resolved)));
               } catch (err) {
-                logger5.debug(`Failed to capture output: ${err}`);
+                logger6.debug(`Failed to capture output: ${err}`);
               }
             }
             if (opts.postprocessResult) {
@@ -2418,7 +2460,7 @@ function decorateSpan(opts, fn) {
                 const boundInputs = _extractBoundInputs(fn, args);
                 opts.postprocessResult(span2, resolved, boundInputs);
               } catch (err) {
-                logger5.debug(`Postprocess failed: ${err}`);
+                logger6.debug(`Postprocess failed: ${err}`);
               }
             }
             span2.setStatus({ code: SpanStatusCode.OK });
@@ -2438,7 +2480,7 @@ function decorateSpan(opts, fn) {
           try {
             span2.setAttribute("output.value", safeJsonDumps(serializeObj(result)));
           } catch (err) {
-            logger5.debug(`Failed to capture output: ${err}`);
+            logger6.debug(`Failed to capture output: ${err}`);
           }
         }
         if (opts.postprocessResult) {
@@ -2446,7 +2488,7 @@ function decorateSpan(opts, fn) {
             const boundInputs = _extractBoundInputs(fn, args);
             opts.postprocessResult(span2, result, boundInputs);
           } catch (err) {
-            logger5.debug(`Postprocess failed: ${err}`);
+            logger6.debug(`Postprocess failed: ${err}`);
           }
         }
         span2.setStatus({ code: SpanStatusCode.OK });
@@ -2480,7 +2522,7 @@ function _extractBoundInputs(fn, args) {
 }
 
 // src/core/context.ts
-var logger6 = getLogger();
+var logger7 = getLogger();
 var _sessionConfig = {};
 function _setSessionConfig(config) {
   _sessionConfig = config;
@@ -2504,6 +2546,7 @@ var KNOWN_OPTION_KEYS = /* @__PURE__ */ new Set([
   "version",
   "mask",
   "attributes",
+  "sessionId",
   "endUserId",
   "endUserMetadata"
 ]);
@@ -2522,7 +2565,7 @@ function _finalizePromptCapture(span2, isPromptTemplateObj, isUserPromptTemplate
         "llm.prompt_template_variables",
         JSON.stringify(capturedVars)
       );
-      logger6.debug(
+      logger7.debug(
         `[trace] Auto-captured variables from PromptContext: ${Object.keys(capturedVars).join(", ")}`
       );
     }
@@ -2534,7 +2577,7 @@ function _finalizePromptCapture(span2, isPromptTemplateObj, isUserPromptTemplate
         "llm.user_prompt_template_variables",
         JSON.stringify(capturedUserVars)
       );
-      logger6.debug(
+      logger7.debug(
         `[trace] Auto-captured variables from UserPromptContext: ${Object.keys(capturedUserVars).join(", ")}`
       );
     }
@@ -2551,13 +2594,13 @@ async function trace2(options, fn) {
     userPromptVariables,
     version,
     mask,
+    sessionId: sessionIdOption,
     endUserId,
     endUserMetadata,
     attributes: explicitAttributes,
     ...extraOptions
   } = options;
-  const sessionConfig = getSessionConfig();
-  const sessionId = sessionConfig.sessionId;
+  const sessionId = sessionIdOption ?? currentSessionId();
   const currentSpan = otelTrace2.getSpan(otelContext2.active());
   const isInActiveTrace = currentSpan !== void 0 && currentSpan.isRecording();
   const shouldCreateRootTrace = !!sessionId && !isInActiveTrace;
@@ -2568,7 +2611,7 @@ async function trace2(options, fn) {
       isPromptTemplateObj = true;
       const t = promptTemplate.template;
       templateString = typeof t === "string" ? t : JSON.stringify(t);
-      logger6.debug(
+      logger7.debug(
         `[trace] Using PromptTemplate object with variables: ${promptTemplate.variables.join(", ")}`
       );
     } else if (typeof promptTemplate === "string") {
@@ -2585,7 +2628,7 @@ async function trace2(options, fn) {
       isUserPromptTemplateObj = true;
       const t = userPromptTemplate.template;
       userTemplateString = typeof t === "string" ? t : JSON.stringify(t);
-      logger6.debug(
+      logger7.debug(
         `[trace] Using UserPromptTemplate object with variables: ${userPromptTemplate.variables.join(", ")}`
       );
     } else if (typeof userPromptTemplate === "string") {
@@ -2600,23 +2643,23 @@ async function trace2(options, fn) {
   const userVariablesJson = userPromptVariables ? JSON.stringify(userPromptVariables) : void 0;
   if (variablesJson) {
     ctx = ctx.setValue(PROMPT_VARIABLES_KEY, variablesJson);
-    logger6.debug(`[trace] Set neatlogs.prompt_variables in context: ${variablesJson}`);
+    logger7.debug(`[trace] Set neatlogs.prompt_variables in context: ${variablesJson}`);
   }
   if (templateString) {
     ctx = ctx.setValue(PROMPT_TEMPLATE_KEY, templateString);
-    logger6.debug(`[trace] Set neatlogs.prompt_template in context: ${templateString}`);
+    logger7.debug(`[trace] Set neatlogs.prompt_template in context: ${templateString}`);
   }
   if (userVariablesJson) {
     ctx = ctx.setValue(USER_PROMPT_VARIABLES_KEY, userVariablesJson);
-    logger6.debug(`[trace] Set neatlogs.user_prompt_variables in context: ${userVariablesJson}`);
+    logger7.debug(`[trace] Set neatlogs.user_prompt_variables in context: ${userVariablesJson}`);
   }
   if (userTemplateString) {
     ctx = ctx.setValue(USER_PROMPT_TEMPLATE_KEY, userTemplateString);
-    logger6.debug(`[trace] Set neatlogs.user_prompt_template in context: ${userTemplateString}`);
+    logger7.debug(`[trace] Set neatlogs.user_prompt_template in context: ${userTemplateString}`);
   }
   if (version) {
     ctx = ctx.setValue(PROMPT_VERSION_KEY, version);
-    logger6.debug(`[trace] Set neatlogs.prompt_version in context: ${version}`);
+    logger7.debug(`[trace] Set neatlogs.prompt_version in context: ${version}`);
   }
   const extraAttributes = { ...explicitAttributes ?? {} };
   for (const [key, value] of Object.entries(extraOptions)) {
@@ -2628,6 +2671,7 @@ async function trace2(options, fn) {
   const tracer = otelTrace2.getTracer("neatlogs.trace");
   const spanCallback = async (span2) => {
     _setSpanAttributes(span2, kind, extraAttributes);
+    applySessionAttributes(span2, sessionId, isRootTrace);
     applyEndUserAttributes(span2, endUserId, endUserMetadata, isRootTrace);
     if (input !== void 0 && input !== null) {
       span2.setAttribute("input.value", safeJsonDumps(serializeObj(input)));
@@ -2667,23 +2711,23 @@ async function trace2(options, fn) {
     }
   };
   if (shouldCreateRootTrace) {
-    logger6.debug(`[trace] Creating NEW root trace '${name}' (sessionId=${sessionId})`);
+    logger7.debug(`[trace] Creating NEW root trace '${name}' (sessionId=${sessionId})`);
     return tracer.startActiveSpan(name, {}, ROOT_CONTEXT, spanCallback);
   } else {
-    logger6.debug(`[trace] Creating child span '${name}'`);
+    logger7.debug(`[trace] Creating child span '${name}'`);
     return tracer.startActiveSpan(name, {}, ctx, spanCallback);
   }
 }
 
 // src/core/crewai-task-registry.ts
-var logger7 = getLogger();
+var logger8 = getLogger();
 var _registry = /* @__PURE__ */ new Map();
 function registerCrewaiTask(task, userTpl, vars) {
   const taskId = String(task.id);
   const tplStr = String(userTpl.template);
   const varsJson = vars && Object.keys(vars).length > 0 ? JSON.stringify(vars, (_key, val) => typeof val === "undefined" ? null : val) : null;
   _registry.set(taskId, [tplStr, varsJson]);
-  logger7.debug(`Registered CrewAI task ${taskId}`);
+  logger8.debug(`Registered CrewAI task ${taskId}`);
 }
 function popEntry(taskId) {
   const entry = _registry.get(taskId);
@@ -3825,7 +3869,7 @@ var attribute_mapping_default = {
 };
 
 // src/config/attribute-mapper.ts
-var logger8 = getLogger();
+var logger9 = getLogger();
 function flattenSources(sources) {
   if (!sources) return [];
   if (Array.isArray(sources)) return sources;
@@ -4146,7 +4190,7 @@ var AttributeMapper = class {
 };
 
 // src/core/span-processor.ts
-var logger9 = getLogger();
+var logger10 = getLogger();
 function resolveLogFilePath(configuredPath) {
   return path.isAbsolute(configuredPath) ? configuredPath : path.join(process.cwd(), configuredPath);
 }
@@ -4159,7 +4203,7 @@ function createLogStream(configuredPath) {
     const stream = fs.createWriteStream(logPath, { fd, autoClose: true });
     fd = null;
     stream.on("error", (error) => {
-      logger9.warn(`Failed to write span log file ${logPath}: ${error}`);
+      logger10.warn(`Failed to write span log file ${logPath}: ${error}`);
       stream.destroy();
     });
     return stream;
@@ -4170,7 +4214,7 @@ function createLogStream(configuredPath) {
       } catch {
       }
     }
-    logger9.warn(`Failed to open span log file ${logPath}: ${error}`);
+    logger10.warn(`Failed to open span log file ${logPath}: ${error}`);
     return null;
   }
 }
@@ -4179,7 +4223,7 @@ async function closeLogStream(stream, description) {
   if (!stream || stream.destroyed || stream.writableEnded) {
     return;
   }
-  await new Promise((resolve2) => {
+  await new Promise((resolve) => {
     let settled = false;
     const settle = () => {
       if (settled) return;
@@ -4187,15 +4231,15 @@ async function closeLogStream(stream, description) {
       clearTimeout(timer);
       stream.off("close", closeHandler);
       stream.off("error", errorHandler);
-      resolve2();
+      resolve();
     };
     const closeHandler = settle;
     const errorHandler = (error) => {
-      logger9.warn(`Failed to close ${description} log file handle: ${error}`);
+      logger10.warn(`Failed to close ${description} log file handle: ${error}`);
       settle();
     };
     const timer = setTimeout(() => {
-      logger9.warn(
+      logger10.warn(
         `Timed out waiting for ${description} log stream to close; destroying`
       );
       stream.destroy();
@@ -4206,7 +4250,7 @@ async function closeLogStream(stream, description) {
     try {
       stream.end();
     } catch (error) {
-      logger9.warn(`Failed to close ${description} log file handle: ${error}`);
+      logger10.warn(`Failed to close ${description} log file handle: ${error}`);
       settle();
     }
   });
@@ -4285,7 +4329,7 @@ var NeatlogsSpanProcessor = class {
       const rawPath = process.env.NEATLOGS_LOG_RAW_SPANS_FILE ?? "spans_raw_optimized.log";
       this._rawLogStream = createLogStream(rawPath);
       if (this._rawLogStream) {
-        logger9.info(
+        logger10.info(
           `Raw span logging enabled: ${resolveLogFilePath(rawPath)}`
         );
       }
@@ -4297,7 +4341,7 @@ var NeatlogsSpanProcessor = class {
       const processedPath = process.env.NEATLOGS_LOG_SPANS_FILE ?? "spans_optimized.log";
       this._processedLogStream = createLogStream(processedPath);
       if (this._processedLogStream) {
-        logger9.info(
+        logger10.info(
           `Processed span logging enabled: ${resolveLogFilePath(processedPath)}`
         );
       }
@@ -4343,14 +4387,14 @@ var NeatlogsSpanProcessor = class {
         }
       }
       if (this.debug) {
-        logger9.debug(
+        logger10.debug(
           `[SpanProcessor.onStart] LLM span '${spanName}' starting`
         );
-        logger9.debug(`  variables_json from context: ${variablesJson}`);
-        logger9.debug(`  template from context: ${template}`);
-        logger9.debug(`  version from context: ${versionVal}`);
-        logger9.debug(`  user_template from context: ${userTemplate}`);
-        logger9.debug(
+        logger10.debug(`  variables_json from context: ${variablesJson}`);
+        logger10.debug(`  template from context: ${template}`);
+        logger10.debug(`  version from context: ${versionVal}`);
+        logger10.debug(`  user_template from context: ${userTemplate}`);
+        logger10.debug(
           `  user_variables_json from context: ${userVariablesJson}`
         );
       }
@@ -4385,7 +4429,7 @@ var NeatlogsSpanProcessor = class {
     this.perfStats.spansProcessed += 1;
     try {
       if (this.debug) {
-        logger9.debug(`[SpanProcessor.onEnd] Span ending: ${span2.name}`);
+        logger10.debug(`[SpanProcessor.onEnd] Span ending: ${span2.name}`);
       }
       if (this._rawLogStream && !this._rawLogStream.destroyed) {
         try {
@@ -4393,7 +4437,7 @@ var NeatlogsSpanProcessor = class {
             JSON.stringify(spanToDict(span2)) + "\n"
           );
         } catch (e) {
-          logger9.warn(`Failed to write span to raw log file: ${e}`);
+          logger10.warn(`Failed to write span to raw log file: ${e}`);
         }
       }
       if (this.sampleRate < 1 && Math.random() > this.sampleRate) {
@@ -4416,7 +4460,7 @@ var NeatlogsSpanProcessor = class {
           delete unifiedAttrs[key];
         }
         if (this.debug && keysToRemove.length > 0) {
-          logger9.debug(
+          logger10.debug(
             `[EMBEDDING Filter] Removed ${keysToRemove.length} large attribute keys from ${nlKind} span (skip_output=${skipOutput})`
           );
         }
@@ -4443,7 +4487,7 @@ var NeatlogsSpanProcessor = class {
           this._retrieversToSuppress.delete(spanId2);
           unifiedAttrs["neatlogs.internal"] = true;
           if (this.debug) {
-            logger9.debug(
+            logger10.debug(
               `[Retriever Merge] Marked OI retriever '${span2.name}' as internal (had neatlogs retriever child)`
             );
           }
@@ -4461,7 +4505,7 @@ var NeatlogsSpanProcessor = class {
           }
         }
         if (this.debug && "neatlogs.tags" in resourceAttrs) {
-          logger9.debug(
+          logger10.debug(
             `[Tags] Span ${span2.name}: resource.neatlogs.tags = ${resourceAttrs["neatlogs.tags"]}`
           );
         }
@@ -4471,7 +4515,7 @@ var NeatlogsSpanProcessor = class {
       let parentSpanId = span2.parentSpanId ?? null;
       if (parentSpanId === spanId) {
         if (this.debug) {
-          logger9.warn(
+          logger10.warn(
             `[SpanProcessor] Detected self-parenting span. trace_id=${traceId} span_id=${spanId} name=${span2.name}. Setting parent_span_id=None.`
           );
         }
@@ -4534,7 +4578,7 @@ var NeatlogsSpanProcessor = class {
         }
       } catch (wbExc) {
         if (this.debug) {
-          logger9.debug(
+          logger10.debug(
             `[SpanProcessor] Attr write-back failed: ${wbExc}`
           );
         }
@@ -4545,7 +4589,7 @@ var NeatlogsSpanProcessor = class {
             JSON.stringify(spanData) + "\n"
           );
         } catch (e) {
-          logger9.warn(`Failed to write span to processed log file: ${e}`);
+          logger10.warn(`Failed to write span to processed log file: ${e}`);
         }
       }
       this.perfStats.spansExported += 1;
@@ -4577,12 +4621,12 @@ var NeatlogsSpanProcessor = class {
       }
       marker.end();
       if (this.debug) {
-        logger9.debug(
+        logger10.debug(
           `[SpanProcessor] Emitted completion marker for trace ${traceId}`
         );
       }
     } catch (e) {
-      logger9.warn(`[SpanProcessor] Failed to emit completion marker: ${e}`);
+      logger10.warn(`[SpanProcessor] Failed to emit completion marker: ${e}`);
     }
   }
   // ── Framework span name normalization ─────────────────
@@ -4649,7 +4693,7 @@ var NeatlogsSpanProcessor = class {
         if (respMeta?.model_name && respMeta.model_name !== currentModel) {
           attrs["neatlogs.llm.model_name"] = respMeta.model_name;
           if (this.debug) {
-            logger9.debug(
+            logger10.debug(
               `[ModelResolve] LangChain span: ${currentModel} \u2192 ${respMeta.model_name}`
             );
           }
@@ -4659,13 +4703,13 @@ var NeatlogsSpanProcessor = class {
       if (output?.model && output.model !== currentModel) {
         attrs["neatlogs.llm.model_name"] = output.model;
         if (this.debug) {
-          logger9.debug(
+          logger10.debug(
             `[ModelResolve] Direct response: ${currentModel} \u2192 ${output.model}`
           );
         }
       }
     } catch (e) {
-      logger9.warn(`[ModelResolve] Failed to parse LLM output for model extraction: ${e}`);
+      logger10.warn(`[ModelResolve] Failed to parse LLM output for model extraction: ${e}`);
     }
   }
   // ── forceFlush / shutdown ─────────────────────────────
@@ -4686,7 +4730,7 @@ var NeatlogsSpanProcessor = class {
     const totalTime = stats.onStartTime + stats.onEndTime;
     const avgMs = totalTime / stats.spansProcessed;
     try {
-      logger9.info(
+      logger10.info(
         `Neatlogs overhead: ${totalTime.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms/span (${stats.spansProcessed} spans processed, ${stats.spansExported} spans logged)`
       );
     } catch {
@@ -4727,187 +4771,9 @@ var FilteringExporter = class {
   }
 };
 
-// src/core/exporter.ts
-var logger10 = getLogger();
-var NeatlogsExporter = class {
-  baseUrl;
-  apiKey;
-  batchSize;
-  flushIntervalMs;
-  disableExport;
-  buffer = [];
-  flushTimer = null;
-  _shutdown = false;
-  constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/$/, "");
-    this.apiKey = options.apiKey;
-    this.batchSize = options.batchSize ?? 50;
-    this.flushIntervalMs = options.flushIntervalMs ?? 5e3;
-    this.disableExport = options.disableExport ?? false;
-    if (!this.disableExport) {
-      this.flushTimer = setInterval(() => this.flush(), this.flushIntervalMs);
-      if (this.flushTimer.unref) {
-        this.flushTimer.unref();
-      }
-    }
-  }
-  /** Add a span-like dict to the buffer. */
-  export(spanData) {
-    if (this._shutdown || this.disableExport) return;
-    this.buffer.push(spanData);
-    if (this.buffer.length >= this.batchSize) {
-      this.flush().catch((err) => {
-        logger10.warn(`Failed to flush batch: ${err}`);
-      });
-    }
-  }
-  /** Flush all buffered spans to the API. */
-  async flush() {
-    if (this.disableExport || this.buffer.length === 0) return;
-    const batch = this.buffer.splice(0, this.buffer.length);
-    try {
-      const url = `${this.baseUrl}/api/data/v4/batch`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": this.apiKey
-        },
-        body: JSON.stringify({ spans: batch })
-      });
-      if (!response.ok) {
-        logger10.warn(
-          `Failed to export batch: ${response.status} ${response.statusText}`
-        );
-        this._requeueBatch(batch);
-      } else {
-        logger10.debug(`Exported ${batch.length} log spans`);
-      }
-    } catch (err) {
-      logger10.warn(`Failed to export batch: ${err}`);
-      this._requeueBatch(batch);
-    }
-  }
-  /** Re-insert a failed batch into the buffer for retry, up to a limit. */
-  _requeueBatch(batch) {
-    if (this.buffer.length < this.batchSize * 3) {
-      this.buffer.unshift(...batch);
-    }
-  }
-  /** Shutdown the exporter, flushing remaining items. */
-  async shutdown() {
-    this._shutdown = true;
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-      this.flushTimer = null;
-    }
-    await this.flush();
-  }
-};
-
-// src/core/log-exporter.ts
-import * as crypto from "crypto";
-import * as fs2 from "fs";
-import * as path2 from "path";
-
-// node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
-import { createContextKey as createContextKey2 } from "@opentelemetry/api";
-var SUPPRESS_TRACING_KEY = createContextKey2("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
-function suppressTracing(context3) {
-  return context3.setValue(SUPPRESS_TRACING_KEY, true);
-}
-
-// node_modules/@opentelemetry/core/build/esm/ExportResult.js
-var ExportResultCode;
-(function(ExportResultCode2) {
-  ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
-  ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
-})(ExportResultCode || (ExportResultCode = {}));
-
-// src/core/log-exporter.ts
-var logger11 = getLogger();
-var NeatlogsLogExporter = class {
-  exporter;
-  logFileHandle = null;
-  logEnabled;
-  constructor(exporter) {
-    this.exporter = exporter;
-    this.logEnabled = ["1", "true", "yes"].includes(
-      (process.env.NEATLOGS_LOG_LOGS ?? "").toLowerCase()
-    );
-    const logFile = process.env.NEATLOGS_LOG_LOGS_FILE ?? "";
-    if (this.logEnabled && logFile) {
-      const filePath = path2.resolve(process.cwd(), logFile);
-      try {
-        this.logFileHandle = fs2.openSync(filePath, "a");
-        logger11.info(`Log record logging enabled: ${filePath}`);
-      } catch (err) {
-        logger11.warn(`Failed to open log file ${filePath}: ${err}`);
-      }
-    }
-  }
-  export(logRecords, resultCallback) {
-    try {
-      for (const record of logRecords) {
-        const spanDict = this._convertLogRecord(record);
-        this.exporter.export(spanDict);
-        this._writeToFile(record, spanDict);
-      }
-      resultCallback({ code: ExportResultCode.SUCCESS });
-    } catch (err) {
-      logger11.warn(`Failed to export log records: ${err}`);
-      resultCallback({ code: ExportResultCode.FAILED });
-    }
-  }
-  async shutdown() {
-    if (this.logFileHandle !== null) {
-      fs2.closeSync(this.logFileHandle);
-      this.logFileHandle = null;
-    }
-  }
-  async forceFlush() {
-    await this.exporter.flush();
-  }
-  _writeToFile(record, spanDict) {
-    if (!this.logEnabled || this.logFileHandle === null) return;
-    const entry = {
-      trace_id: spanDict.trace_id || "",
-      span_id: spanDict.span_id || "",
-      body: spanDict.attributes?.["log.message"] ?? "",
-      severity: record.severityText ?? "",
-      template: spanDict.attributes?.["log.template"] ?? "",
-      timestamp: spanDict.start_time
-    };
-    fs2.writeSync(this.logFileHandle, JSON.stringify(entry) + "\n");
-  }
-  _convertLogRecord(record) {
-    const attributes = { ...record.attributes ?? {} };
-    if (record.body !== void 0 && record.body !== null) {
-      attributes["log.message"] = String(record.body);
-    }
-    attributes["openinference.span.kind"] = "LOG";
-    attributes["neatlogs.span.kind"] = "log";
-    return {
-      name: attributes["log.template"] ?? "log",
-      kind: "LOG",
-      trace_id: record.spanContext?.traceId ?? "",
-      span_id: crypto.randomBytes(8).toString("hex"),
-      parent_span_id: record.spanContext?.spanId ?? "",
-      start_time: record.hrTime ? this._hrTimeToIso(record.hrTime) : (/* @__PURE__ */ new Date()).toISOString(),
-      end_time: record.hrTime ? this._hrTimeToIso(record.hrTime) : (/* @__PURE__ */ new Date()).toISOString(),
-      status: "OK",
-      attributes
-    };
-  }
-  _hrTimeToIso(hrTime) {
-    const ms = hrTime[0] * 1e3 + hrTime[1] / 1e6;
-    return new Date(ms).toISOString();
-  }
-};
-
 // src/core/log.ts
 import { context, trace as trace3 } from "@opentelemetry/api";
-var logger12 = getLogger();
+var logger11 = getLogger();
 var _otelLogger = null;
 var _debugMode = false;
 function _setOtelLogger(otelLogger, debug) {
@@ -4940,7 +4806,7 @@ function log(msgTemplate, options) {
         ...spanContext ? { spanContext } : {}
       });
     } catch (err) {
-      logger12.warn(`Failed to emit log record: ${err}`);
+      logger11.warn(`Failed to emit log record: ${err}`);
     }
   }
 }
@@ -5369,7 +5235,7 @@ function getLibraryInfo(library) {
 }
 
 // src/instrumentation/manager.ts
-var logger13 = getLogger();
+var logger12 = getLogger();
 var InstrumentationManager = class {
   provider;
   _instrumented = [];
@@ -5388,7 +5254,7 @@ var InstrumentationManager = class {
     for (const lib of libraries) {
       const info = getLibraryInfo(lib);
       if (!info) {
-        logger13.warn(
+        logger12.warn(
           `Unknown library '${lib}' \u2014 not in instrumentation registry. Skipping.`
         );
         continue;
@@ -5404,7 +5270,7 @@ var InstrumentationManager = class {
             if (typeof instrumentor.instrument === "function") {
               instrumentor.instrument({ tracerProvider: this.provider });
               this._instrumented.push(lib);
-              logger13.debug(
+              logger12.debug(
                 `Instrumented '${lib}' via neatlogs custom instrumentor`
               );
               continue;
@@ -5417,23 +5283,23 @@ var InstrumentationManager = class {
                   const targetMod = await import(info.npm_package);
                   instrumentor.patchEager(targetMod);
                 } catch (e) {
-                  logger13.debug(
+                  logger12.debug(
                     `Eager patch for '${lib}' skipped \u2014 ${info.npm_package} not available: ${e}`
                   );
                 }
               }
               this._instrumented.push(lib);
-              logger13.debug(
+              logger12.debug(
                 `Instrumented '${lib}' via neatlogs OTel instrumentor`
               );
               continue;
             }
           }
-          logger13.debug(
+          logger12.debug(
             `neatlogs instrumentor for '${lib}' loaded but has no instrument() method \u2014 trying OpenInference`
           );
         } catch (err) {
-          logger13.debug(
+          logger12.debug(
             `neatlogs instrumentor for '${lib}' failed to load: ${err} \u2014 trying OpenInference`
           );
         }
@@ -5449,7 +5315,7 @@ var InstrumentationManager = class {
             if (typeof instrumentor.instrument === "function") {
               instrumentor.instrument({ tracerProvider: this.provider });
               this._instrumented.push(lib);
-              logger13.debug(`Instrumented '${lib}' via OpenInference`);
+              logger12.debug(`Instrumented '${lib}' via OpenInference`);
               continue;
             }
             if (typeof instrumentor.setTracerProvider === "function" && typeof instrumentor.manuallyInstrument === "function") {
@@ -5459,16 +5325,16 @@ var InstrumentationManager = class {
                   const targetMod = await import(info.npm_package);
                   instrumentor.manuallyInstrument(targetMod);
                   this._instrumented.push(lib);
-                  logger13.debug(`Instrumented '${lib}' via OpenInference (manual patch)`);
+                  logger12.debug(`Instrumented '${lib}' via OpenInference (manual patch)`);
                   continue;
                 } catch (importErr) {
-                  logger13.debug(
+                  logger12.debug(
                     `Could not import '${info.npm_package}' for manual instrumentation of '${lib}': ${importErr}`
                   );
                 }
               }
               this._instrumented.push(lib);
-              logger13.debug(`Instrumented '${lib}' via OpenInference (tracer set, awaiting module hook)`);
+              logger12.debug(`Instrumented '${lib}' via OpenInference (tracer set, awaiting module hook)`);
               continue;
             }
           }
@@ -5477,32 +5343,41 @@ var InstrumentationManager = class {
               tracerProvider: this.provider
             });
             this._instrumented.push(lib);
-            logger13.debug(`Instrumented '${lib}' via OpenInference`);
+            logger12.debug(`Instrumented '${lib}' via OpenInference`);
             continue;
           }
-          logger13.warn(
+          logger12.warn(
             `OpenInference package for '${lib}' loaded but could not find instrumentor class`
           );
         } catch (err) {
-          logger13.debug(
+          logger12.debug(
             `OpenInference instrumentor for '${lib}' not available: ${err}`
           );
         }
       }
       if (!info.openinference && !info.neatlogs) {
-        logger13.debug(
+        logger12.debug(
           `'${lib}' instrumentation not yet available for TypeScript \u2014 skipping`
         );
       }
     }
     if (this._instrumented.length > 0) {
-      logger13.info(`Instrumented: ${this._instrumented.join(", ")}`);
+      logger12.info(`Instrumented: ${this._instrumented.join(", ")}`);
     }
   }
 };
 
 // src/prompt/client.ts
 import { context as context2 } from "@opentelemetry/api";
+
+// node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+import { createContextKey as createContextKey2 } from "@opentelemetry/api";
+var SUPPRESS_TRACING_KEY = createContextKey2("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+function suppressTracing(context3) {
+  return context3.setValue(SUPPRESS_TRACING_KEY, true);
+}
+
+// src/prompt/client.ts
 var PromptClientError = class extends Error {
   constructor(message) {
     super(message);
@@ -5691,8 +5566,8 @@ var PromptClient = class {
     const version = options?.version;
     const label = options?.label;
     if (label != null) {
-      const path4 = `/api/v1/prompts/${encodeURIComponent(name)}/fetch`;
-      const url = `${path4}?label=${encodeURIComponent(label)}`;
+      const path3 = `/api/v1/prompts/${encodeURIComponent(name)}/fetch`;
+      const url = `${path3}?label=${encodeURIComponent(label)}`;
       const payload = await this._request(url);
       return new PromptHandle(normalizePromptObject(payload));
     }
@@ -5796,8 +5671,8 @@ var PromptClient = class {
   /**
    * Internal fetch wrapper with auth headers and OTel suppression.
    */
-  async _request(path4, options) {
-    const url = `${this.baseUrl}${path4}`;
+  async _request(path3, options) {
+    const url = `${this.baseUrl}${path3}`;
     const headers = {
       Accept: "application/json",
       "Content-Type": "application/json",
@@ -5820,13 +5695,13 @@ var PromptClient = class {
     if (!response.ok) {
       const body = await response.text().catch(() => "<unavailable>");
       throw new PromptApiError(
-        `${fetchOptions.method} ${path4} failed (${response.status}): ${body.slice(0, 400)}`
+        `${fetchOptions.method} ${path3} failed (${response.status}): ${body.slice(0, 400)}`
       );
     }
     try {
       return await response.json();
     } catch {
-      throw new PromptApiError(`${fetchOptions.method} ${path4} returned non-JSON response`);
+      throw new PromptApiError(`${fetchOptions.method} ${path3} returned non-JSON response`);
     }
   }
 };
@@ -5868,15 +5743,14 @@ async function removeTag(name, tag) {
 }
 
 // src/version.ts
-var __version__ = "1.1.0";
+var __version__ = "1.1.2";
 
 // src/init.ts
-var logger14 = getLogger();
+var logger13 = getLogger();
 var _initialized = false;
 var _tracerProvider = null;
 var _meterProvider = null;
 var _logProvider = null;
-var _logSpanExporter = null;
 var _spanProcessor = null;
 var _debugMode2 = false;
 var _sigHandlersRegistered = false;
@@ -5888,19 +5762,16 @@ function _resolveWorkflowName(workflowName) {
   const provided = (workflowName ?? "").trim();
   if (provided) return provided;
   const argv1 = process.argv[1] ?? "";
-  const base = path3.basename(argv1, path3.extname(argv1));
+  const base = path2.basename(argv1, path2.extname(argv1));
   const slug = base.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
   if (slug && !["node", "ts-node", "tsx", "npx", "-e"].includes(slug)) {
     return slug;
   }
   return "neatlogs-app";
 }
-function _randomHex(bytes) {
-  return randomBytes2(bytes).toString("hex");
-}
 async function init(options = {}) {
   if (_initialized) {
-    logger14.warn("Neatlogs already initialized, skipping re-initialization");
+    logger13.warn("Neatlogs already initialized, skipping re-initialization");
     return;
   }
   let resolvedKey;
@@ -5916,7 +5787,7 @@ async function init(options = {}) {
     disableExportResolved = true;
     resolvedKey = "disabled";
     if (options.debug) {
-      logger14.warn(
+      logger13.warn(
         "No NEATLOGS_API_KEY set; HTTP export disabled. Set NEATLOGS_API_KEY (or pass apiKey) to send spans to the backend."
       );
     }
@@ -5926,17 +5797,9 @@ async function init(options = {}) {
   }
   _debugMode2 = options.debug ?? false;
   const resolvedWorkflowName = _resolveWorkflowName(options.workflowName);
-  let sessionId = options.sessionId;
-  if (!sessionId && options.autoSession) {
-    sessionId = `session_${Date.now()}_${_randomHex(4)}`;
-    if (options.debug) {
-      logger14.debug(`Auto-generated session_id: ${sessionId}`);
-    }
-  }
-  const endpoint = options.endpoint ?? "https://staging-cloud.neatlogs.com";
+  const endpoint = options.endpoint ?? "https://ingest.neatlogs.com";
   const baseUrl = new URL(endpoint).origin;
   _setSessionConfig({
-    sessionId,
     userId: options.userId,
     workflowName: resolvedWorkflowName,
     _apiKey: resolvedKey,
@@ -5950,15 +5813,7 @@ async function init(options = {}) {
     "service.version": __version__,
     "neatlogs.workflow_name": resolvedWorkflowName
   };
-  if (sessionId) resourceAttrs["session.id"] = sessionId;
   if (options.userId) resourceAttrs["user.id"] = options.userId;
-  if (options.endUserId) {
-    resourceAttrs[END_USER_ID_KEY] = String(options.endUserId);
-  }
-  if (options.endUserMetadata) {
-    const euMeta = normalizeEndUserMetadata(options.endUserMetadata);
-    if (euMeta) resourceAttrs[END_USER_METADATA_KEY] = euMeta;
-  }
   const tags = options.tags;
   if (tags !== void 0) {
     if (!Array.isArray(tags) || !tags.every((t) => typeof t === "string")) {
@@ -5997,40 +5852,30 @@ async function init(options = {}) {
     });
     provider.addSpanProcessor(batchProcessor);
     if (options.debug) {
-      logger14.debug(`OTLP trace exporter configured: ${tracesEndpoint}`);
+      logger13.debug(`OTLP trace exporter configured: ${tracesEndpoint}`);
     }
   } else if (options.debug) {
-    logger14.debug("Export disabled \u2014 spans will not be sent to backend");
+    logger13.debug("Export disabled \u2014 spans will not be sent to backend");
   }
   provider.register();
   _tracerProvider = provider;
   if (options.debug) {
-    logger14.debug("Neatlogs tracer provider initialized");
+    logger13.debug("Neatlogs tracer provider initialized");
   }
   try {
     _meterProvider = new MeterProvider({ resource });
     metrics.setGlobalMeterProvider(_meterProvider);
     if (options.debug) {
-      logger14.debug("Neatlogs meter provider initialized");
+      logger13.debug("Neatlogs meter provider initialized");
     }
   } catch {
     if (options.debug) {
-      logger14.debug("MeterProvider not available \u2014 skipping");
+      logger13.debug("MeterProvider not available \u2014 skipping");
     }
   }
   const captureLogs = options.captureLogs ?? false;
   if (captureLogs) {
-    _logSpanExporter = new NeatlogsExporter({
-      baseUrl,
-      apiKey: resolvedKey,
-      batchSize: options.batchSize ?? 100,
-      flushIntervalMs: (options.flushInterval ?? 5) * 1e3,
-      disableExport: disableExportResolved
-    });
     _logProvider = new LoggerProvider({ resource });
-    _logProvider.addLogRecordProcessor(
-      new SimpleLogRecordProcessor(new NeatlogsLogExporter(_logSpanExporter))
-    );
     if (!disableExportResolved) {
       const logsEndpoint = endpoint.endsWith("/v1/logs") ? endpoint : `${baseUrl}/v1/logs`;
       const otlpLogExporter = new OTLPLogExporter({
@@ -6038,20 +5883,23 @@ async function init(options = {}) {
         headers: resolvedKey ? { "x-api-key": resolvedKey } : void 0
       });
       _logProvider.addLogRecordProcessor(
-        new BatchLogRecordProcessor(otlpLogExporter)
+        new BatchLogRecordProcessor(otlpLogExporter, {
+          maxExportBatchSize: options.batchSize ?? 100,
+          scheduledDelayMillis: (options.flushInterval ?? 5) * 1e3
+        })
       );
       if (options.debug) {
-        logger14.debug(`OTLP log exporter configured: ${logsEndpoint}`);
+        logger13.debug(`OTLP log exporter configured: ${logsEndpoint}`);
       }
     }
     logs.setGlobalLoggerProvider(_logProvider);
     const otelLogger = _logProvider.getLogger("neatlogs");
     _setOtelLogger(otelLogger, options.debug ?? false);
     if (options.debug) {
-      logger14.debug(`Neatlogs log capture enabled (endpoint: ${baseUrl}/v1/logs)`);
+      logger13.debug(`Neatlogs log capture enabled (endpoint: ${baseUrl}/v1/logs)`);
     }
   } else if (options.debug) {
-    logger14.debug("Log capture disabled (pass captureLogs: true to enable)");
+    logger13.debug("Log capture disabled (pass captureLogs: true to enable)");
   }
   const manager = new InstrumentationManager({
     provider,
@@ -6060,7 +5908,7 @@ async function init(options = {}) {
   if (options.instrumentations?.length) {
     await manager.instrument(options.instrumentations);
     if (options.debug) {
-      logger14.debug(`Instrumented libraries: ${manager.instrumented.join(", ")}`);
+      logger13.debug(`Instrumented libraries: ${manager.instrumented.join(", ")}`);
     }
   }
   if (!_sigHandlersRegistered) {
@@ -6071,45 +5919,44 @@ async function init(options = {}) {
   }
   _initialized = true;
   if (options.debug) {
-    logger14.info("Neatlogs SDK initialized successfully");
-    logger14.info(`Endpoint: ${endpoint}`);
-    logger14.info(`Workflow: ${resolvedWorkflowName}`);
-    logger14.info(`Session: ${sessionId ?? "(none)"}`);
-    logger14.info(`User: ${options.userId ?? "(none)"}`);
-    logger14.info(`Tags: ${tags ?? []}`);
-    logger14.info(`Instrumentations: ${manager.instrumented.join(", ") || "(none)"}`);
-    logger14.info(`Sample Rate: ${options.sampleRate ?? 1}`);
+    logger13.info("Neatlogs SDK initialized successfully");
+    logger13.info(`Endpoint: ${endpoint}`);
+    logger13.info(`Workflow: ${resolvedWorkflowName}`);
+    logger13.info(`User: ${options.userId ?? "(none)"}`);
+    logger13.info(`Tags: ${tags ?? []}`);
+    logger13.info(`Instrumentations: ${manager.instrumented.join(", ") || "(none)"}`);
+    logger13.info(`Sample Rate: ${options.sampleRate ?? 1}`);
   }
 }
 async function flush() {
   let success = true;
   if (_tracerProvider) {
     try {
-      logger14.debug("Flushing tracer provider...");
+      logger13.debug("Flushing tracer provider...");
       await _tracerProvider.forceFlush();
-      logger14.debug("Tracer provider flushed successfully");
+      logger13.debug("Tracer provider flushed successfully");
     } catch (e) {
-      logger14.error(`Error flushing spans: ${e}`);
+      logger13.error(`Error flushing spans: ${e}`);
       success = false;
     }
   }
   if (_meterProvider) {
     try {
-      logger14.debug("Flushing meter provider...");
+      logger13.debug("Flushing meter provider...");
       await _meterProvider.forceFlush();
-      logger14.debug("Meter provider flushed successfully");
+      logger13.debug("Meter provider flushed successfully");
     } catch (e) {
-      logger14.error(`Error flushing metrics: ${e}`);
+      logger13.error(`Error flushing metrics: ${e}`);
       success = false;
     }
   }
-  if (_logSpanExporter) {
+  if (_logProvider) {
     try {
-      logger14.debug("Flushing log span exporter...");
-      await _logSpanExporter.flush();
-      logger14.debug("Log span exporter flushed successfully");
+      logger13.debug("Flushing log provider...");
+      await _logProvider.forceFlush();
+      logger13.debug("Log provider flushed successfully");
     } catch (e) {
-      logger14.error(`Error flushing logs: ${e}`);
+      logger13.error(`Error flushing logs: ${e}`);
       success = false;
     }
   }
@@ -6125,41 +5972,31 @@ async function shutdown() {
   let success = true;
   if (_tracerProvider) {
     try {
-      logger14.debug("Shutting down tracer provider...");
+      logger13.debug("Shutting down tracer provider...");
       await _tracerProvider.shutdown();
-      logger14.debug("Tracer provider shut down successfully");
+      logger13.debug("Tracer provider shut down successfully");
     } catch (e) {
-      logger14.error(`Error shutting down tracer provider: ${e}`);
+      logger13.error(`Error shutting down tracer provider: ${e}`);
       success = false;
     }
   }
   if (_meterProvider) {
     try {
-      logger14.debug("Shutting down meter provider...");
+      logger13.debug("Shutting down meter provider...");
       await _meterProvider.shutdown();
-      logger14.debug("Meter provider shut down successfully");
+      logger13.debug("Meter provider shut down successfully");
     } catch (e) {
-      logger14.error(`Error shutting down meter provider: ${e}`);
+      logger13.error(`Error shutting down meter provider: ${e}`);
       success = false;
     }
   }
   if (_logProvider) {
     try {
-      logger14.debug("Shutting down log provider...");
+      logger13.debug("Shutting down log provider...");
       await _logProvider.shutdown();
-      logger14.debug("Log provider shut down successfully");
-    } catch (e) {
-      logger14.error(`Error shutting down log provider: ${e}`);
-      success = false;
-    }
-  }
-  if (_logSpanExporter) {
-    try {
-      logger14.debug("Shutting down log span exporter...");
-      await _logSpanExporter.shutdown();
-      logger14.debug("Log span exporter shut down successfully");
+      logger13.debug("Log provider shut down successfully");
     } catch (e) {
-      logger14.error(`Error shutting down log span exporter: ${e}`);
+      logger13.error(`Error shutting down log provider: ${e}`);
       success = false;
     }
   }
@@ -6167,11 +6004,10 @@ async function shutdown() {
   _tracerProvider = null;
   _meterProvider = null;
   _logProvider = null;
-  _logSpanExporter = null;
   _spanProcessor = null;
   _debugMode2 = false;
   _setSessionConfig({});
-  logger14.info("Neatlogs SDK shutdown complete");
+  logger13.info("Neatlogs SDK shutdown complete");
   return success;
 }
 function getTracerProvider() {
@@ -6187,7 +6023,7 @@ function isDebugEnabled() {
 }
 
 // src/decorators/orchestration.ts
-var logger15 = getLogger();
+var logger14 = getLogger();
 function span(options, fn) {
   if (!VALID_SPAN_KINDS.has(options.kind)) {
     throw new Error(
@@ -6528,6 +6364,10 @@ function resolveRootWorkflowName() {
   }
   return "workflow";
 }
+function stampAutoRootIdentity(root) {
+  applySessionAttributes(root, void 0, true);
+  applyEndUserAttributes(root, void 0, void 0, true);
+}
 function wrapSpanWithRoot(child, root) {
   let ended = false;
   return new Proxy(child, {
@@ -6562,6 +6402,7 @@ function maybeOpenAutoRoot(tracer, kind, baseCtx) {
     { attributes: { "neatlogs.span.kind": "workflow", "neatlogs.auto_root": true } },
     baseCtx
   );
+  stampAutoRootIdentity(root);
   return { root, ctx: otelTrace4.setSpan(baseCtx, root) };
 }
 function endAutoRoot(root) {
@@ -6591,6 +6432,7 @@ var AutoRootTracer = class {
       { attributes: { "neatlogs.span.kind": "workflow", "neatlogs.auto_root": true } },
       ctx
     );
+    stampAutoRootIdentity(root);
     const childCtx = otelTrace4.setSpan(ctx, root);
     const child = this._tracer.startSpan(name, options, childCtx);
     return wrapSpanWithRoot(child, root);
@@ -6639,12 +6481,12 @@ function traceTool(name, fn) {
     );
   };
 }
-function wrapNamespace(target, path4) {
+function wrapNamespace(target, path3) {
   return new Proxy(target, {
     get(obj, prop, receiver) {
       const value = Reflect.get(obj, prop, receiver);
       if (typeof prop === "symbol" || String(prop).startsWith("_")) return value;
-      const currentPath = [...path4, String(prop)];
+      const currentPath = [...path3, String(prop)];
       const pathStr = currentPath.join(".");
       if (pathStr === "chat.completions.create" && typeof value === "function") {
         return tracedChatCompletionsCreate(value.bind(obj));
@@ -6659,9 +6501,9 @@ function wrapNamespace(target, path4) {
     }
   });
 }
-function isNamespace(path4) {
-  if (path4.length > 3) return false;
-  const key = path4[path4.length - 1];
+function isNamespace(path3) {
+  if (path3.length > 3) return false;
+  const key = path3[path3.length - 1];
   return ["chat", "completions", "responses", "beta"].includes(key);
 }
 function tracedChatCompletionsCreate(original) {
@@ -6951,12 +6793,12 @@ function traceTool2(name, fn) {
     );
   };
 }
-function wrapNamespace2(target, path4) {
+function wrapNamespace2(target, path3) {
   return new Proxy(target, {
     get(obj, prop, receiver) {
       const value = Reflect.get(obj, prop, receiver);
       if (typeof prop === "symbol" || String(prop).startsWith("_")) return value;
-      const currentPath = [...path4, String(prop)];
+      const currentPath = [...path3, String(prop)];
       const pathStr = currentPath.join(".");
       if (pathStr === "messages.create" && typeof value === "function") {
         return tracedMessagesCreate(value.bind(obj));
@@ -6971,9 +6813,9 @@ function wrapNamespace2(target, path4) {
     }
   });
 }
-function isNamespace2(path4) {
-  if (path4.length > 3) return false;
-  const key = path4[path4.length - 1];
+function isNamespace2(path3) {
+  if (path3.length > 3) return false;
+  const key = path3[path3.length - 1];
   return ["messages", "beta"].includes(key);
 }
 function tracedMessagesCreate(original) {
@@ -7296,12 +7138,12 @@ function traceTool3(name, fn) {
     );
   };
 }
-function wrapNamespace3(target, path4) {
+function wrapNamespace3(target, path3) {
   return new Proxy(target, {
     get(obj, prop, receiver) {
       const value = Reflect.get(obj, prop, receiver);
       if (typeof prop === "symbol" || String(prop).startsWith("_")) return value;
-      const currentPath = [...path4, String(prop)];
+      const currentPath = [...path3, String(prop)];
       const pathStr = currentPath.join(".");
       if (pathStr === "chat.completions.create" && typeof value === "function") {
         return tracedChatCompletionsCreate2(value.bind(obj));
@@ -7316,9 +7158,9 @@ function wrapNamespace3(target, path4) {
     }
   });
 }
-function isNamespace3(path4) {
-  if (path4.length > 3) return false;
-  const key = path4[path4.length - 1];
+function isNamespace3(path3) {
+  if (path3.length > 3) return false;
+  const key = path3[path3.length - 1];
   return ["chat", "completions", "responses", "beta"].includes(key);
 }
 function tracedChatCompletionsCreate2(original) {
@@ -7610,12 +7452,12 @@ function traceTool4(name, fn) {
     );
   };
 }
-function wrapNamespace4(target, path4) {
+function wrapNamespace4(target, path3) {
   return new Proxy(target, {
     get(obj, prop, receiver) {
       const value = Reflect.get(obj, prop, receiver);
       if (typeof prop === "symbol" || String(prop).startsWith("_")) return value;
-      const currentPath = [...path4, String(prop)];
+      const currentPath = [...path3, String(prop)];
       const pathStr = currentPath.join(".");
       if (pathStr === "models.generateContent" && typeof value === "function") {
         return tracedGenerateContent(value.bind(obj), false);
@@ -7636,9 +7478,9 @@ function wrapNamespace4(target, path4) {
     }
   });
 }
-function isNamespace4(path4) {
-  if (path4.length > 2) return false;
-  return ["models", "chats"].includes(path4[path4.length - 1]);
+function isNamespace4(path3) {
+  if (path3.length > 2) return false;
+  return ["models", "chats"].includes(path3[path3.length - 1]);
 }
 function wrapVertexAIChat(chat) {
   const c = chat;
@@ -10593,21 +10435,21 @@ var ExportTraceServiceRequest = protoRoot.lookupType(
   "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest"
 );
 var SpanStatusCode16 = { UNSET: 0, OK: 1, ERROR: 2 };
-function randomBytes3(length) {
+function randomBytes(length) {
   const out = new Uint8Array(length);
-  const crypto2 = globalThis.crypto;
-  if (crypto2 && typeof crypto2.getRandomValues === "function") {
-    crypto2.getRandomValues(out);
+  const crypto = globalThis.crypto;
+  if (crypto && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(out);
     return out;
   }
   for (let i = 0; i < out.length; i++) out[i] = Math.floor(Math.random() * 256);
   return out;
 }
 function generateTraceId() {
-  return randomBytes3(16);
+  return randomBytes(16);
 }
 function generateSpanId() {
-  return randomBytes3(8);
+  return randomBytes(8);
 }
 function nowNanoString() {
   return (BigInt(Date.now()) * 1000000n).toString();
@@ -10749,7 +10591,7 @@ function nanoToLong(nanoStr) {
 }
 
 // src/opencode-plugin.ts
-var DEFAULT_ENDPOINT = "https://staging-cloud.neatlogs.com";
+var DEFAULT_ENDPOINT = "https://ingest.neatlogs.com";
 var NeatlogsOpencodePlugin = async (_ctx) => {
   const apiKey = (process.env.NEATLOGS_API_KEY ?? "").trim();
   const endpoint = (process.env.NEATLOGS_ENDPOINT ?? DEFAULT_ENDPOINT).trim();
@@ -11073,7 +10915,7 @@ function safeStringify15(value) {
 }
 
 // src/core/llm-binder.ts
-var logger16 = getLogger();
+var logger15 = getLogger();
 function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
   const systemStr = String(systemTpl.template);
   const userStr = userTpl ? String(userTpl.template) : null;
@@ -11085,7 +10927,7 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
       llmCopy = structuredClone(llm);
     } catch {
       llmCopy = llm;
-      logger16.debug(
+      logger15.debug(
         `LLM type ${llm?.constructor?.name ?? "unknown"} is not copyable \u2014 binding in place.`
       );
     }
@@ -11096,7 +10938,7 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
   } else if (typeof llmCopy.call === "function") {
     methodName = "call";
   } else {
-    logger16.warn(
+    logger15.warn(
       `LLM type ${llm?.constructor?.name ?? "unknown"} has neither invoke() nor call() \u2014 prompt templates will not be captured on spans.`
     );
     return llmCopy;
@@ -11116,7 +10958,7 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
       }
     }
   };
-  logger16.debug(
+  logger15.debug(
     `Wrapped ${llm?.constructor?.name ?? "unknown"}.${methodName}() with template injection.`
   );
   return llmCopy;
@@ -11141,6 +10983,7 @@ export {
   getMastraObservability,
   getPrompt,
   getSessionConfig,
+  identify,
   init,
   isDebugEnabled,
   langchainHandler,