neatlogs 1.1.2 → 1.1.5

package/dist/google-genai.mjs

@@ -0,0 +1,622 @@
+// src/google-genai.ts
+import { trace as trace2, context as otelContext4, SpanStatusCode as SpanStatusCode3 } from "@opentelemetry/api";
+
+// src/core/auto-root.ts
+import {
+  trace as otelTrace3,
+  context as otelContext3
+} from "@opentelemetry/api";
+
+// src/core/context.ts
+import {
+  trace as otelTrace2,
+  context as otelContext2,
+  createContextKey,
+  ROOT_CONTEXT,
+  SpanStatusCode as SpanStatusCode2
+} from "@opentelemetry/api";
+
+// src/prompt/template.ts
+import { AsyncLocalStorage } from "async_hooks";
+var _promptStorage = new AsyncLocalStorage();
+var _userPromptStorage = new AsyncLocalStorage();
+
+// src/core/logger.ts
+var LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  NONE: 4
+};
+var _logLevel = "INFO";
+var _disabled = false;
+function _getConfiguredLevel() {
+  const envLevel = process.env.NEATLOGS_LOG_LEVEL?.toUpperCase();
+  if (envLevel && envLevel in LOG_LEVELS) {
+    return envLevel;
+  }
+  return "INFO";
+}
+_logLevel = _getConfiguredLevel();
+function getLogger() {
+  return {
+    debug(message, ...args) {
+      if (!_disabled && LOG_LEVELS[_logLevel] <= LOG_LEVELS.DEBUG) {
+        console.debug(`[neatlogs] ${message}`, ...args);
+      }
+    },
+    info(message, ...args) {
+      if (!_disabled && LOG_LEVELS[_logLevel] <= LOG_LEVELS.INFO) {
+        console.info(`[neatlogs] ${message}`, ...args);
+      }
+    },
+    warn(message, ...args) {
+      if (!_disabled && LOG_LEVELS[_logLevel] <= LOG_LEVELS.WARN) {
+        console.warn(`[neatlogs] ${message}`, ...args);
+      }
+    },
+    error(message, ...args) {
+      if (!_disabled && LOG_LEVELS[_logLevel] <= LOG_LEVELS.ERROR) {
+        console.error(`[neatlogs] ${message}`, ...args);
+      }
+    }
+  };
+}
+
+// src/core/mask.ts
+var logger = getLogger();
+
+// 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;
+}
+
+// src/core/end-user.ts
+var logger2 = getLogger();
+var END_USER_ID_KEY = "neatlogs.end_user.id";
+var END_USER_METADATA_KEY = "neatlogs.end_user.metadata";
+function normalizeEndUserMetadata(metadata) {
+  if (metadata === void 0 || metadata === null) return void 0;
+  if (typeof metadata === "string") return metadata || void 0;
+  try {
+    return JSON.stringify(metadata);
+  } catch {
+    return JSON.stringify(String(metadata));
+  }
+}
+function applyEndUserAttributes(span, endUserId, endUserMetadata, isRoot = true) {
+  const resolvedId = isRoot ? endUserId ?? currentEndUserId() : endUserId;
+  const resolvedMeta = isRoot ? endUserMetadata ?? currentEndUserMetadata() : endUserMetadata;
+  if (!resolvedId && !resolvedMeta) return;
+  if (!isRoot) {
+    logger2.debug(
+      "[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 (resolvedId) {
+    span.setAttribute(END_USER_ID_KEY, String(resolvedId));
+  }
+  const metaJson = normalizeEndUserMetadata(resolvedMeta);
+  if (metaJson) {
+    span.setAttribute(END_USER_METADATA_KEY, metaJson);
+  }
+}
+
+// src/core/session.ts
+var logger3 = getLogger();
+var SESSION_ID_KEY = "neatlogs.session.id";
+function applySessionAttributes(span, sessionId, isRoot = true) {
+  const resolved = isRoot ? sessionId ?? currentSessionId() : sessionId;
+  if (!resolved) return;
+  if (!isRoot) {
+    logger3.debug(
+      "[session] Ignoring sessionId on a non-root span \u2014 declare it on the trace root (top-level trace()/span()) or identify()."
+    );
+    return;
+  }
+  span.setAttribute(SESSION_ID_KEY, String(resolved));
+}
+
+// src/decorators/base.ts
+import { trace, SpanStatusCode } from "@opentelemetry/api";
+var logger4 = getLogger();
+
+// src/core/context.ts
+var logger5 = getLogger();
+var _sessionConfig = {};
+function getSessionConfig() {
+  return { ..._sessionConfig };
+}
+var PROMPT_VARIABLES_KEY = createContextKey("neatlogs.prompt_variables");
+var PROMPT_TEMPLATE_KEY = createContextKey("neatlogs.prompt_template");
+var PROMPT_VERSION_KEY = createContextKey("neatlogs.prompt_version");
+var USER_PROMPT_TEMPLATE_KEY = createContextKey("neatlogs.user_prompt_template");
+var USER_PROMPT_VARIABLES_KEY = createContextKey("neatlogs.user_prompt_variables");
+
+// src/core/auto-root.ts
+var ROOT_KINDS = /* @__PURE__ */ new Set(["workflow", "chain", "agent", "mcp_tool"]);
+function autoRootEnabled() {
+  const val = (process.env.NEATLOGS_AUTO_ROOT ?? "").trim().toLowerCase();
+  return !["false", "0", "no", "off"].includes(val);
+}
+function resolveRootWorkflowName() {
+  try {
+    const name = getSessionConfig()?.workflowName;
+    if (typeof name === "string" && name.trim()) return name;
+  } catch {
+  }
+  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, {
+    get(target, prop, _receiver) {
+      if (prop === "end") {
+        return (...args) => {
+          if (ended) return;
+          ended = true;
+          try {
+            target.end(...args);
+          } finally {
+            try {
+              root.end();
+            } catch {
+            }
+          }
+        };
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+var AutoRootTracer = class {
+  constructor(_tracer) {
+    this._tracer = _tracer;
+  }
+  _tracer;
+  startSpan(name, options, context) {
+    const kind = String(
+      options?.attributes?.["neatlogs.span.kind"] ?? ""
+    ).toLowerCase();
+    const ctx = context ?? otelContext3.active();
+    const parent = otelTrace3.getSpan(ctx);
+    const needsRoot = autoRootEnabled() && !ROOT_KINDS.has(kind) && !(parent !== void 0 && parent.isRecording());
+    if (!needsRoot) {
+      return this._tracer.startSpan(name, options, context);
+    }
+    const root = this._tracer.startSpan(
+      resolveRootWorkflowName(),
+      { attributes: { "neatlogs.span.kind": "workflow", "neatlogs.auto_root": true } },
+      ctx
+    );
+    stampAutoRootIdentity(root);
+    const childCtx = otelTrace3.setSpan(ctx, root);
+    const child = this._tracer.startSpan(name, options, childCtx);
+    return wrapSpanWithRoot(child, root);
+  }
+  // startActiveSpan is used by traceTool (callback-scoped, always under an
+  // active span in practice) — pass straight through, no auto-root.
+  startActiveSpan = ((...args) => this._tracer.startActiveSpan(
+    ...args
+  ));
+};
+function getProviderTracer(name) {
+  return new AutoRootTracer(otelTrace3.getTracer(name));
+}
+
+// src/google-genai.ts
+var TRACER_NAME = "neatlogs.google_genai";
+var PROVIDER = "google";
+var SYSTEM = "google_genai";
+function wrapGoogleGenAI(client) {
+  return wrapNamespace(client, []);
+}
+function traceTool(name, fn) {
+  return async function tracedTool(args) {
+    const tracer = getProviderTracer(TRACER_NAME);
+    return tracer.startActiveSpan(
+      `tool.${name}`,
+      {
+        attributes: {
+          "neatlogs.span.kind": "TOOL",
+          "neatlogs.tool.name": name,
+          "input.value": safeStringify(args)
+        }
+      },
+      otelContext4.active(),
+      async (span) => {
+        try {
+          const result = await fn(args);
+          span.setAttribute("output.value", safeStringify(result));
+          span.setStatus({ code: SpanStatusCode3.OK });
+          return result;
+        } catch (err) {
+          recordError(span, err);
+          throw err;
+        } finally {
+          span.end();
+        }
+      }
+    );
+  };
+}
+function wrapNamespace(target, path) {
+  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 = [...path, String(prop)];
+      const pathStr = currentPath.join(".");
+      if (pathStr === "models.generateContent" && typeof value === "function") {
+        return tracedGenerateContent(value.bind(obj), false);
+      }
+      if (pathStr === "models.generateContentStream" && typeof value === "function") {
+        return tracedGenerateContent(value.bind(obj), true);
+      }
+      if (pathStr === "models.embedContent" && typeof value === "function") {
+        return tracedEmbedContent(value.bind(obj));
+      }
+      if (pathStr === "models.countTokens" && typeof value === "function") {
+        return tracedCountTokens(value.bind(obj));
+      }
+      if (value && typeof value === "object" && !Array.isArray(value) && isNamespace(currentPath)) {
+        return wrapNamespace(value, currentPath);
+      }
+      return value;
+    }
+  });
+}
+function isNamespace(path) {
+  if (path.length > 2) return false;
+  return ["models", "chats"].includes(path[path.length - 1]);
+}
+function wrapGoogleGenAIChat(chat) {
+  const c = chat;
+  if (!c || c._neatlogsGoogleGenAIPatched) return chat;
+  if (typeof c.sendMessage === "function") {
+    const orig = c.sendMessage.bind(c);
+    c.sendMessage = (params, ...rest) => tracedChatSend(orig, c, params, rest, false);
+  }
+  if (typeof c.sendMessageStream === "function") {
+    const orig = c.sendMessageStream.bind(c);
+    c.sendMessageStream = (params, ...rest) => tracedChatSend(orig, c, params, rest, true);
+  }
+  try {
+    Object.defineProperty(c, "_neatlogsGoogleGenAIPatched", { value: true, enumerable: false, configurable: true });
+  } catch {
+    c._neatlogsGoogleGenAIPatched = true;
+  }
+  return chat;
+}
+function tracedChatSend(original, chat, params, rest, isStream) {
+  const tracer = getProviderTracer(TRACER_NAME);
+  const model = chat?.model ?? chat?.modelVersion ?? "";
+  const span = tracer.startSpan("google_genai.chat.send_message", {
+    attributes: {
+      "neatlogs.span.kind": "LLM",
+      "neatlogs.llm.provider": PROVIDER,
+      "neatlogs.llm.system": SYSTEM,
+      "neatlogs.llm.model_name": model,
+      "neatlogs.llm.is_streaming": isStream
+    }
+  }, otelContext4.active());
+  const message = params?.message ?? params;
+  span.setAttribute("neatlogs.llm.input_messages.0.role", "user");
+  span.setAttribute(
+    "neatlogs.llm.input_messages.0.content",
+    typeof message === "string" ? message : safeStringify(message)
+  );
+  const ctx = trace2.setSpan(otelContext4.active(), span);
+  const result = otelContext4.with(ctx, () => original(params, ...rest));
+  return Promise.resolve(result).then(
+    (response) => {
+      if (isStream) return wrapStream(response, span);
+      finalizeResponse(span, response);
+      return response;
+    },
+    (err) => {
+      recordError(span, err);
+      throw err;
+    }
+  );
+}
+function tracedEmbedContent(original) {
+  return function(opts, ...rest) {
+    const tracer = getProviderTracer(TRACER_NAME);
+    const span = tracer.startSpan("google_genai.models.embed_content", {
+      attributes: {
+        "neatlogs.span.kind": "EMBEDDING",
+        "neatlogs.llm.provider": PROVIDER,
+        "neatlogs.embedding.model_name": opts?.model ?? "",
+        "neatlogs.embedding.text": safeStringify(opts?.contents ?? "")
+      }
+    }, otelContext4.active());
+    const ctx = trace2.setSpan(otelContext4.active(), span);
+    const result = otelContext4.with(ctx, () => original(opts, ...rest));
+    return Promise.resolve(result).then(
+      (response) => {
+        const embeddings = response?.embeddings;
+        if (Array.isArray(embeddings)) {
+          span.setAttribute("neatlogs.embedding.count", embeddings.length);
+          const vals = embeddings[0]?.values;
+          if (Array.isArray(vals)) span.setAttribute("neatlogs.embedding.dimensions", vals.length);
+        }
+        span.setStatus({ code: SpanStatusCode3.OK });
+        span.end();
+        return response;
+      },
+      (err) => {
+        recordError(span, err);
+        throw err;
+      }
+    );
+  };
+}
+function tracedCountTokens(original) {
+  return function(opts, ...rest) {
+    const tracer = getProviderTracer(TRACER_NAME);
+    const span = tracer.startSpan("google_genai.models.count_tokens", {
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": PROVIDER,
+        "neatlogs.llm.task": "count_tokens",
+        "neatlogs.llm.model_name": opts?.model ?? ""
+      }
+    }, otelContext4.active());
+    const ctx = trace2.setSpan(otelContext4.active(), span);
+    const result = otelContext4.with(ctx, () => original(opts, ...rest));
+    return Promise.resolve(result).then(
+      (response) => {
+        if (response?.totalTokens != null) span.setAttribute("neatlogs.llm.token_count.prompt", response.totalTokens);
+        span.setStatus({ code: SpanStatusCode3.OK });
+        span.end();
+        return response;
+      },
+      (err) => {
+        recordError(span, err);
+        throw err;
+      }
+    );
+  };
+}
+function tracedGenerateContent(original, isStream) {
+  return function(opts, ...rest) {
+    const tracer = getProviderTracer(TRACER_NAME);
+    const model = opts?.model ?? "";
+    const span = tracer.startSpan("google_genai.models.generate_content", {
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": PROVIDER,
+        "neatlogs.llm.system": SYSTEM,
+        "neatlogs.llm.model_name": model,
+        "neatlogs.llm.is_streaming": isStream
+      }
+    }, otelContext4.active());
+    setInputAttributes(span, opts);
+    const ctx = trace2.setSpan(otelContext4.active(), span);
+    const result = otelContext4.with(ctx, () => original(opts, ...rest));
+    return Promise.resolve(result).then(
+      (response) => {
+        if (isStream) {
+          return wrapStream(response, span);
+        }
+        finalizeResponse(span, response);
+        return response;
+      },
+      (err) => {
+        recordError(span, err);
+        throw err;
+      }
+    );
+  };
+}
+function setInputAttributes(span, opts) {
+  let idx = 0;
+  const config = opts?.config;
+  const systemInstruction = config?.systemInstruction ?? config?.system_instruction;
+  if (systemInstruction) {
+    span.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "system");
+    span.setAttribute(
+      `neatlogs.llm.input_messages.${idx}.content`,
+      typeof systemInstruction === "string" ? systemInstruction : safeStringify(systemInstruction)
+    );
+    idx++;
+  }
+  const contents = opts?.contents;
+  if (typeof contents === "string") {
+    span.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "user");
+    span.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, contents);
+  } else if (Array.isArray(contents)) {
+    for (const item of contents) {
+      if (typeof item === "string") {
+        span.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "user");
+        span.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, item);
+        idx++;
+      } else if (item && typeof item === "object") {
+        const role = item.role ?? "user";
+        span.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, role);
+        const parts = item.parts ?? [];
+        const textParts = [];
+        for (const part of parts) {
+          if (typeof part === "string") textParts.push(part);
+          else if (part?.text) textParts.push(part.text);
+        }
+        span.setAttribute(
+          `neatlogs.llm.input_messages.${idx}.content`,
+          textParts.length ? textParts.join("\n") : safeStringify(parts)
+        );
+        idx++;
+      }
+    }
+  } else if (contents) {
+    span.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "user");
+    span.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, safeStringify(contents));
+  }
+  const tools = config?.tools;
+  if (Array.isArray(tools)) {
+    let t = 0;
+    for (const tool of tools) {
+      const decls = tool?.functionDeclarations ?? tool?.function_declarations ?? [];
+      for (const fn of decls) {
+        span.setAttribute(`neatlogs.llm.tools.${t}.name`, fn?.name ?? "");
+        if (fn?.description) span.setAttribute(`neatlogs.llm.tools.${t}.description`, fn.description);
+        if (fn?.parameters) span.setAttribute(`neatlogs.llm.tools.${t}.input_schema`, safeStringify(fn.parameters));
+        t++;
+      }
+    }
+  }
+  if (config) {
+    if (config.temperature != null) span.setAttribute("neatlogs.llm.temperature", config.temperature);
+    if (config.topP != null) span.setAttribute("neatlogs.llm.top_p", config.topP);
+    if (config.topK != null) span.setAttribute("neatlogs.llm.top_k", config.topK);
+    const maxTokens = config.maxOutputTokens ?? config.max_output_tokens;
+    if (maxTokens != null) span.setAttribute("neatlogs.llm.max_tokens", maxTokens);
+    const params = {};
+    if (config.temperature != null) params.temperature = config.temperature;
+    if (config.topP != null) params.top_p = config.topP;
+    if (config.topK != null) params.top_k = config.topK;
+    if (maxTokens != null) params.max_tokens = maxTokens;
+    if (config.frequencyPenalty != null) params.frequency_penalty = config.frequencyPenalty;
+    if (config.presencePenalty != null) params.presence_penalty = config.presencePenalty;
+    if (Object.keys(params).length > 0) {
+      span.setAttribute("neatlogs.llm.invocation_parameters", JSON.stringify(params));
+    }
+  }
+}
+function wrapStream(stream, span) {
+  const chunks = [];
+  const originalAsyncIterator = stream?.[Symbol.asyncIterator]?.bind(stream);
+  if (!originalAsyncIterator) {
+    finalizeStreamChunks(span, chunks);
+    return stream;
+  }
+  const wrapped = Object.create(Object.getPrototypeOf(stream));
+  Object.assign(wrapped, stream);
+  wrapped[Symbol.asyncIterator] = function() {
+    const iterator = originalAsyncIterator();
+    return {
+      async next() {
+        try {
+          const result = await iterator.next();
+          if (result.done) {
+            finalizeStreamChunks(span, chunks);
+            return result;
+          }
+          chunks.push(result.value);
+          return result;
+        } catch (err) {
+          recordError(span, err);
+          throw err;
+        }
+      },
+      async return(value) {
+        finalizeStreamChunks(span, chunks);
+        return iterator.return?.(value) ?? { done: true, value: void 0 };
+      },
+      async throw(err) {
+        recordError(span, err);
+        return iterator.throw?.(err) ?? { done: true, value: void 0 };
+      }
+    };
+  };
+  return wrapped;
+}
+function finalizeStreamChunks(span, chunks) {
+  const textParts = [];
+  let finishReason = "";
+  let usage = null;
+  for (const chunk of chunks) {
+    for (const candidate of chunk?.candidates ?? []) {
+      for (const part of candidate?.content?.parts ?? []) {
+        if (part?.text && !part?.thought) textParts.push(part.text);
+      }
+      if (candidate?.finishReason) finishReason = candidate.finishReason;
+    }
+    if (chunk?.usageMetadata) usage = chunk.usageMetadata;
+  }
+  const fullText = textParts.join("");
+  if (fullText) {
+    span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span.setAttribute("neatlogs.llm.output_messages.0.content", fullText);
+  }
+  if (finishReason) span.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
+  setUsage(span, usage);
+  span.setStatus({ code: SpanStatusCode3.OK });
+  span.end();
+}
+function finalizeResponse(span, response) {
+  const textParts = [];
+  let toolIdx = 0;
+  for (const candidate of response?.candidates ?? []) {
+    for (const part of candidate?.content?.parts ?? []) {
+      if (part?.text && !part?.thought) {
+        textParts.push(part.text);
+      } else if (part?.thought && part?.text) {
+        span.setAttribute("neatlogs.llm.output_messages.0.thinking", part.text);
+      } else if (part?.functionCall) {
+        const fc = part.functionCall;
+        span.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.name`, fc?.name ?? "");
+        span.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.arguments`, safeStringify(fc?.args ?? {}));
+        toolIdx++;
+      }
+    }
+    if (candidate?.finishReason) span.setAttribute("neatlogs.llm.finish_reason", String(candidate.finishReason));
+  }
+  if (textParts.length) {
+    span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join(""));
+  }
+  setUsage(span, response?.usageMetadata);
+  span.setStatus({ code: SpanStatusCode3.OK });
+  span.end();
+}
+function setUsage(span, usage) {
+  if (!usage) return;
+  if (usage.promptTokenCount != null) span.setAttribute("neatlogs.llm.token_count.prompt", usage.promptTokenCount);
+  if (usage.candidatesTokenCount != null) span.setAttribute("neatlogs.llm.token_count.completion", usage.candidatesTokenCount);
+  if (usage.totalTokenCount != null) span.setAttribute("neatlogs.llm.token_count.total", usage.totalTokenCount);
+  if (usage.cachedContentTokenCount != null) span.setAttribute("neatlogs.llm.token_count.cache_read", usage.cachedContentTokenCount);
+  if (usage.thoughtsTokenCount != null) span.setAttribute("neatlogs.llm.token_count.reasoning", usage.thoughtsTokenCount);
+}
+function safeStringify(value) {
+  try {
+    return typeof value === "string" ? value : JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function recordError(span, err) {
+  if (err instanceof Error) {
+    span.setStatus({ code: SpanStatusCode3.ERROR, message: err.message });
+    span.recordException(err);
+  } else {
+    span.setStatus({ code: SpanStatusCode3.ERROR, message: String(err) });
+  }
+  span.end();
+}
+export {
+  traceTool,
+  wrapGoogleGenAI,
+  wrapGoogleGenAIChat
+};
+//# sourceMappingURL=google-genai.mjs.map