@struktur/telemetry 2.1.2 → 2.3.0

package/dist/factory.js

@@ -0,0 +1,592 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/adapters/phoenix/PhoenixAdapter.ts
+function createPhoenixAdapter(config) {
+  return new PhoenixAdapter(config);
+}
+var PhoenixAdapter;
+var init_PhoenixAdapter = __esm({
+  "src/adapters/phoenix/PhoenixAdapter.ts"() {
+    "use strict";
+    PhoenixAdapter = class {
+      name = "phoenix";
+      version = "1.0.0";
+      config;
+      tracerProvider = null;
+      activeSpans = /* @__PURE__ */ new Map();
+      otelApi = null;
+      phoenixOtel = null;
+      constructor(config) {
+        this.config = {
+          url: "http://localhost:6006",
+          batch: true,
+          ...config
+        };
+      }
+      async initialize() {
+        const [{ register }, otelApi] = await Promise.all([
+          import("@arizeai/phoenix-otel"),
+          import("@opentelemetry/api")
+        ]);
+        this.otelApi = otelApi;
+        this.phoenixOtel = { register };
+        this.tracerProvider = register({
+          projectName: this.config.projectName,
+          url: this.config.url,
+          apiKey: this.config.apiKey,
+          batch: this.config.batch,
+          headers: this.config.headers
+        });
+      }
+      async shutdown() {
+        if (this.tracerProvider?.forceFlush) {
+          await this.tracerProvider.forceFlush();
+        }
+      }
+      startSpan(context) {
+        if (!this.otelApi) {
+          throw new Error("PhoenixAdapter not initialized");
+        }
+        const tracer = this.otelApi.trace.getTracer("struktur");
+        const spanKind = context.kind;
+        const otelSpan = tracer.startSpan(context.name, {
+          attributes: {
+            "openinference.span.kind": spanKind,
+            ...context.attributes
+          }
+        });
+        const spanContext = otelSpan.spanContext();
+        const span = {
+          id: spanContext.spanId,
+          traceId: spanContext.traceId,
+          name: context.name,
+          kind: context.kind,
+          startTime: context.startTime ?? Date.now(),
+          parentId: context.parentSpan?.id
+        };
+        this.activeSpans.set(span.id, otelSpan);
+        return span;
+      }
+      endSpan(span, result) {
+        const otelSpan = this.activeSpans.get(span.id);
+        if (!otelSpan) return;
+        if (result) {
+          otelSpan.setStatus({
+            code: result.status === "ok" ? 1 : 2,
+            message: result.error?.message
+          });
+          if (result.output !== void 0) {
+            try {
+              const outputStr = typeof result.output === "string" ? result.output : JSON.stringify(result.output);
+              otelSpan.setAttribute("output.value", outputStr);
+            } catch {
+              otelSpan.setAttribute("output.value", "[object]");
+            }
+          }
+          if (result.latencyMs !== void 0) {
+            otelSpan.setAttribute("latency_ms", result.latencyMs);
+          }
+        }
+        otelSpan.end();
+        this.activeSpans.delete(span.id);
+      }
+      recordEvent(span, event) {
+        const otelSpan = this.activeSpans.get(span.id);
+        if (!otelSpan) return;
+        switch (event.type) {
+          case "llm_call":
+            this.recordLLMCall(otelSpan, event);
+            break;
+          case "validation":
+            this.recordValidation(otelSpan, event);
+            break;
+          case "chunk":
+            this.recordChunk(otelSpan, event);
+            break;
+          case "tool_call":
+            this.recordToolCall(otelSpan, event);
+            break;
+          case "merge":
+            this.recordMerge(otelSpan, event);
+            break;
+          case "parse":
+            this.recordParse(otelSpan, event);
+            break;
+        }
+      }
+      setAttributes(span, attributes) {
+        const otelSpan = this.activeSpans.get(span.id);
+        if (!otelSpan) return;
+        const stringAttrs = {};
+        for (const [key, value] of Object.entries(attributes)) {
+          if (value !== void 0 && value !== null) {
+            if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+              stringAttrs[key] = value;
+            } else {
+              try {
+                stringAttrs[key] = JSON.stringify(value);
+              } catch {
+                stringAttrs[key] = String(value);
+              }
+            }
+          }
+        }
+        otelSpan.setAttributes(stringAttrs);
+      }
+      setContext(_context) {
+      }
+      recordLLMCall(span, event) {
+        const attrs = {
+          "llm.model_name": event.model,
+          "llm.provider": event.provider,
+          "llm.temperature": event.input.temperature ?? "",
+          "llm.max_tokens": event.input.maxTokens ?? ""
+        };
+        if (event.input.messages.length > 0) {
+          attrs["llm.input_messages"] = JSON.stringify(event.input.messages);
+        }
+        if (event.input.schema) {
+          try {
+            attrs["llm.schema"] = JSON.stringify(event.input.schema);
+          } catch {
+          }
+        }
+        if (event.output) {
+          attrs["output.value"] = event.output.content;
+          attrs["llm.structured_output"] = event.output.structured ?? false;
+          if (event.output.usage) {
+            this.setTokenUsageAttrs(attrs, event.output.usage);
+          }
+        }
+        attrs["latency_ms"] = event.latencyMs;
+        if (event.error) {
+          span.recordException(event.error);
+        }
+        span.setAttributes(attrs);
+      }
+      setTokenUsageAttrs(attrs, usage) {
+        attrs["llm.token_count.prompt"] = usage.input;
+        attrs["llm.token_count.completion"] = usage.output;
+        attrs["llm.token_count.total"] = usage.total;
+      }
+      recordValidation(span, event) {
+        const attrs = {
+          "validation.attempt": event.attempt,
+          "validation.max_attempts": event.maxAttempts,
+          "validation.success": event.success
+        };
+        if (event.errors && event.errors.length > 0) {
+          attrs["validation.errors"] = JSON.stringify(event.errors);
+        }
+        if (event.latencyMs !== void 0) {
+          attrs["latency_ms"] = event.latencyMs;
+        }
+        span.setAttributes(attrs);
+      }
+      recordChunk(span, event) {
+        span.setAttributes({
+          "chunk.index": event.chunkIndex,
+          "chunk.total": event.totalChunks,
+          "chunk.tokens": event.tokens,
+          "chunk.images": event.images
+        });
+        if (event.content) {
+          span.setAttribute("chunk.content_preview", event.content.slice(0, 1e3));
+        }
+      }
+      recordToolCall(span, event) {
+        const attrs = {
+          "tool.name": event.toolName,
+          "tool.args": JSON.stringify(event.args)
+        };
+        if (event.result !== void 0) {
+          try {
+            attrs["tool.result"] = JSON.stringify(event.result);
+          } catch {
+            attrs["tool.result"] = "[object]";
+          }
+        }
+        if (event.error) {
+          attrs["tool.error"] = event.error.message;
+        }
+        if (event.latencyMs !== void 0) {
+          attrs["latency_ms"] = event.latencyMs;
+        }
+        span.setAttributes(attrs);
+        if (event.error) {
+          span.recordException(event.error);
+        }
+      }
+      recordMerge(span, event) {
+        const attrs = {
+          "merge.strategy": event.strategy,
+          "merge.input_count": event.inputCount,
+          "merge.output_count": event.outputCount
+        };
+        if (event.deduped !== void 0) {
+          attrs["merge.deduped"] = event.deduped;
+        }
+        span.setAttributes(attrs);
+      }
+      recordParse(span, event) {
+        span.setAttributes({
+          "parse.mime_type": event.mimeType,
+          "parse.parser": event.parser,
+          "parse.input_size": event.inputSize,
+          "parse.output_tokens": event.outputTokens,
+          "parse.output_images": event.outputImages,
+          "latency_ms": event.latencyMs
+        });
+      }
+    };
+  }
+});
+
+// src/adapters/phoenix/index.ts
+var phoenix_exports = {};
+__export(phoenix_exports, {
+  PhoenixAdapter: () => PhoenixAdapter,
+  createPhoenixAdapter: () => createPhoenixAdapter
+});
+var init_phoenix = __esm({
+  "src/adapters/phoenix/index.ts"() {
+    "use strict";
+    init_PhoenixAdapter();
+  }
+});
+
+// src/adapters/langfuse/LangfuseAdapter.ts
+function createLangfuseAdapter(config) {
+  return new LangfuseAdapter(config);
+}
+var LangfuseAdapter;
+var init_LangfuseAdapter = __esm({
+  "src/adapters/langfuse/LangfuseAdapter.ts"() {
+    "use strict";
+    LangfuseAdapter = class {
+      name = "langfuse";
+      version = "1.0.0";
+      config;
+      sdk = null;
+      activeSpans = /* @__PURE__ */ new Map();
+      otelApi = null;
+      constructor(config) {
+        this.config = {
+          baseUrl: "https://cloud.langfuse.com",
+          ...config
+        };
+      }
+      async initialize() {
+        const [{ LangfuseSpanProcessor }, { NodeSDK }, otelApi] = await Promise.all([
+          import("@langfuse/otel"),
+          import("@opentelemetry/sdk-node"),
+          import("@opentelemetry/api")
+        ]);
+        this.otelApi = otelApi;
+        const processor = new LangfuseSpanProcessor({
+          publicKey: this.config.publicKey,
+          secretKey: this.config.secretKey,
+          baseUrl: this.config.baseUrl
+        });
+        const sdk = new NodeSDK({
+          spanProcessors: [processor]
+        });
+        sdk.start();
+        this.sdk = sdk;
+      }
+      async shutdown() {
+        if (this.sdk) {
+          await this.sdk.shutdown();
+        }
+      }
+      startSpan(context) {
+        if (!this.otelApi) {
+          throw new Error("LangfuseAdapter not initialized");
+        }
+        const tracer = this.otelApi.trace.getTracer("struktur");
+        const otelSpan = tracer.startSpan(context.name, {
+          attributes: {
+            "observation.type": context.kind.toLowerCase(),
+            ...context.attributes
+          }
+        });
+        const spanContext = otelSpan.spanContext();
+        const span = {
+          id: spanContext.spanId,
+          traceId: spanContext.traceId,
+          name: context.name,
+          kind: context.kind,
+          startTime: context.startTime ?? Date.now(),
+          parentId: context.parentSpan?.id
+        };
+        this.activeSpans.set(span.id, otelSpan);
+        return span;
+      }
+      endSpan(span, result) {
+        const otelSpan = this.activeSpans.get(span.id);
+        if (!otelSpan) return;
+        if (result) {
+          otelSpan.setStatus({
+            code: result.status === "ok" ? 1 : 2,
+            message: result.error?.message
+          });
+          if (result.output !== void 0) {
+            try {
+              const outputStr = typeof result.output === "string" ? result.output : JSON.stringify(result.output);
+              otelSpan.setAttribute("output", outputStr);
+            } catch {
+              otelSpan.setAttribute("output", "[object]");
+            }
+          }
+          if (result.latencyMs !== void 0) {
+            otelSpan.setAttribute("latency_ms", result.latencyMs);
+          }
+        }
+        otelSpan.end();
+        this.activeSpans.delete(span.id);
+      }
+      recordEvent(span, event) {
+        const otelSpan = this.activeSpans.get(span.id);
+        if (!otelSpan) return;
+        switch (event.type) {
+          case "llm_call":
+            this.recordLLMCall(otelSpan, event);
+            break;
+          case "validation":
+            this.recordValidation(otelSpan, event);
+            break;
+          case "chunk":
+            this.recordChunk(otelSpan, event);
+            break;
+          case "tool_call":
+            this.recordToolCall(otelSpan, event);
+            break;
+          case "merge":
+            this.recordMerge(otelSpan, event);
+            break;
+          case "parse":
+            this.recordParse(otelSpan, event);
+            break;
+        }
+      }
+      setAttributes(span, attributes) {
+        const otelSpan = this.activeSpans.get(span.id);
+        if (!otelSpan) return;
+        const stringAttrs = {};
+        for (const [key, value] of Object.entries(attributes)) {
+          if (value !== void 0 && value !== null) {
+            if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+              stringAttrs[key] = value;
+            } else {
+              try {
+                stringAttrs[key] = JSON.stringify(value);
+              } catch {
+                stringAttrs[key] = String(value);
+              }
+            }
+          }
+        }
+        otelSpan.setAttributes(stringAttrs);
+      }
+      setContext(_context) {
+      }
+      recordLLMCall(span, event) {
+        const attrs = {
+          model: event.model,
+          provider: event.provider,
+          input: JSON.stringify(event.input.messages),
+          temperature: event.input.temperature ?? "",
+          max_tokens: event.input.maxTokens ?? ""
+        };
+        if (event.output) {
+          attrs.output = event.output.content;
+          if (event.output.usage) {
+            attrs["usage.input"] = event.output.usage.input;
+            attrs["usage.output"] = event.output.usage.output;
+            attrs["usage.total"] = event.output.usage.total;
+          }
+        }
+        attrs.latency_ms = event.latencyMs;
+        if (event.error) {
+          attrs.error = event.error.message;
+          span.recordException(event.error);
+        }
+        span.setAttributes(attrs);
+      }
+      recordValidation(span, event) {
+        const attrs = {
+          attempt: event.attempt,
+          max_attempts: event.maxAttempts,
+          success: event.success
+        };
+        if (event.errors && event.errors.length > 0) {
+          attrs.errors = JSON.stringify(event.errors);
+        }
+        if (event.latencyMs !== void 0) {
+          attrs.latency_ms = event.latencyMs;
+        }
+        span.setAttributes(attrs);
+      }
+      recordChunk(span, event) {
+        const attrs = {
+          chunk_index: event.chunkIndex,
+          chunk_total: event.totalChunks,
+          chunk_tokens: event.tokens,
+          chunk_images: event.images
+        };
+        if (event.content) {
+          attrs.chunk_content = event.content.slice(0, 1e3);
+        }
+        span.setAttributes(attrs);
+      }
+      recordToolCall(span, event) {
+        const attrs = {
+          tool_name: event.toolName,
+          tool_args: JSON.stringify(event.args)
+        };
+        if (event.result !== void 0) {
+          try {
+            attrs.tool_result = JSON.stringify(event.result);
+          } catch {
+            attrs.tool_result = "[object]";
+          }
+        }
+        if (event.error) {
+          attrs.tool_error = event.error.message;
+        }
+        if (event.latencyMs !== void 0) {
+          attrs.latency_ms = event.latencyMs;
+        }
+        span.setAttributes(attrs);
+        if (event.error) {
+          span.recordException(event.error);
+        }
+      }
+      recordMerge(span, event) {
+        const attrs = {
+          strategy: event.strategy,
+          input_count: event.inputCount,
+          output_count: event.outputCount
+        };
+        if (event.deduped !== void 0) {
+          attrs.deduped = event.deduped;
+        }
+        span.setAttributes(attrs);
+      }
+      recordParse(span, event) {
+        span.setAttributes({
+          mime_type: event.mimeType,
+          parser: event.parser,
+          input_size: event.inputSize,
+          output_tokens: event.outputTokens,
+          output_images: event.outputImages,
+          latency_ms: event.latencyMs
+        });
+      }
+    };
+  }
+});
+
+// src/adapters/langfuse/index.ts
+var langfuse_exports = {};
+__export(langfuse_exports, {
+  LangfuseAdapter: () => LangfuseAdapter,
+  createLangfuseAdapter: () => createLangfuseAdapter
+});
+var init_langfuse = __esm({
+  "src/adapters/langfuse/index.ts"() {
+    "use strict";
+    init_LangfuseAdapter();
+  }
+});
+
+// src/types.ts
+var NoopTelemetryAdapter = class {
+  name = "noop";
+  version = "1.0.0";
+  currentId = 0;
+  mockSpans = /* @__PURE__ */ new Map();
+  async initialize() {
+  }
+  async shutdown() {
+  }
+  startSpan(context) {
+    const id = `noop-${++this.currentId}`;
+    const span = {
+      id,
+      traceId: `trace-${this.currentId}`,
+      name: context.name,
+      kind: context.kind,
+      startTime: Date.now(),
+      parentId: context.parentSpan?.id
+    };
+    this.mockSpans.set(id, span);
+    return span;
+  }
+  endSpan(span, _result) {
+    this.mockSpans.delete(span.id);
+  }
+  recordEvent(_span, _event) {
+  }
+  setAttributes(_span, _attributes) {
+  }
+  setContext(_context) {
+  }
+};
+
+// src/factory.ts
+async function createTelemetry(options) {
+  if (options.enabled === false) {
+    return null;
+  }
+  const { provider, config } = options;
+  try {
+    switch (provider) {
+      case "phoenix": {
+        const { PhoenixAdapter: PhoenixAdapter2 } = await Promise.resolve().then(() => (init_phoenix(), phoenix_exports));
+        return new PhoenixAdapter2(config);
+      }
+      case "langfuse": {
+        const { LangfuseAdapter: LangfuseAdapter2 } = await Promise.resolve().then(() => (init_langfuse(), langfuse_exports));
+        return new LangfuseAdapter2(config);
+      }
+      default:
+        throw new Error(
+          `Unknown telemetry provider: ${provider}. Supported providers: phoenix, langfuse`
+        );
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Cannot find module")) {
+      throw new Error(
+        `Provider '${provider}' requires optional dependencies. Install them with: bun add @arizeai/phoenix-otel @arizeai/openinference-core or bun add @langfuse/otel`
+      );
+    }
+    throw error;
+  }
+}
+async function createPhoenixTelemetry(config) {
+  const { PhoenixAdapter: PhoenixAdapter2 } = await Promise.resolve().then(() => (init_phoenix(), phoenix_exports));
+  return new PhoenixAdapter2(config);
+}
+async function createLangfuseTelemetry(config) {
+  const { LangfuseAdapter: LangfuseAdapter2 } = await Promise.resolve().then(() => (init_langfuse(), langfuse_exports));
+  return new LangfuseAdapter2(config);
+}
+function createNoopTelemetry() {
+  return new NoopTelemetryAdapter();
+}
+export {
+  createLangfuseTelemetry,
+  createNoopTelemetry,
+  createPhoenixTelemetry,
+  createTelemetry
+};
+//# sourceMappingURL=factory.js.map