@langfuse/tracing 4.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2023 Finto Technologies GmbH
+
+Copyright (c) 2022 PostHog (part of Hiberly Inc)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/attributes.d.ts

@@ -0,0 +1,7 @@
+import { type Attributes } from "@opentelemetry/api";
+import { LangfuseGenerationAttributes, LangfuseSpanAttributes, LangfuseTraceAttributes } from "./types.js";
+export declare function createTraceAttributes({ name, userId, sessionId, version, release, input, output, metadata, tags, environment, public: isPublic, }?: LangfuseTraceAttributes): Attributes;
+export declare function createSpanAttributes({ metadata, input, output, level, statusMessage, version, }: LangfuseSpanAttributes): Attributes;
+export declare function createGenerationAttributes({ completionStartTime, metadata, level, statusMessage, version, model, modelParameters, input, output, usageDetails, costDetails, prompt, }: LangfuseGenerationAttributes): Attributes;
+export declare function createEventAttributes({ metadata, input, output, level, statusMessage, version, }: LangfuseSpanAttributes): Attributes;
+//# sourceMappingURL=attributes.d.ts.map

package/dist/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../src/attributes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EACL,4BAA4B,EAC5B,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,qBAAqB,CAAC,EACpC,IAAI,EACJ,MAAM,EACN,SAAS,EACT,OAAO,EACP,OAAO,EACP,KAAK,EACL,MAAM,EACN,QAAQ,EACR,IAAI,EACJ,WAAW,EACX,MAAM,EAAE,QAAQ,GACjB,GAAE,uBAA4B,GAAG,UAAU,CAkB3C;AAED,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,KAAK,EACL,MAAM,EACN,KAAK,EACL,aAAa,EACb,OAAO,GACR,EAAE,sBAAsB,GAAG,UAAU,CAcrC;AAED,wBAAgB,0BAA0B,CAAC,EACzC,mBAAmB,EACnB,QAAQ,EACR,KAAK,EACL,aAAa,EACb,OAAO,EACP,KAAK,EACL,eAAe,EACf,KAAK,EACL,MAAM,EACN,YAAY,EACZ,WAAW,EACX,MAAM,GACP,EAAE,4BAA4B,GAAG,UAAU,CA8B3C;AAED,wBAAgB,qBAAqB,CAAC,EACpC,QAAQ,EACR,KAAK,EACL,MAAM,EACN,KAAK,EACL,aAAa,EACb,OAAO,GACR,EAAE,sBAAsB,GAAG,UAAU,CAcrC"}

package/dist/attributes.js

@@ -0,0 +1,96 @@
+import { LangfuseOtelSpanAttributes } from "@langfuse/core";
+export function createTraceAttributes({ name, userId, sessionId, version, release, input, output, metadata, tags, environment, public: isPublic, } = {}) {
+    const attributes = {
+        [LangfuseOtelSpanAttributes.TRACE_NAME]: name,
+        [LangfuseOtelSpanAttributes.TRACE_USER_ID]: userId,
+        [LangfuseOtelSpanAttributes.TRACE_SESSION_ID]: sessionId,
+        [LangfuseOtelSpanAttributes.VERSION]: version,
+        [LangfuseOtelSpanAttributes.RELEASE]: release,
+        [LangfuseOtelSpanAttributes.TRACE_INPUT]: _serialize(input),
+        [LangfuseOtelSpanAttributes.TRACE_OUTPUT]: _serialize(output),
+        [LangfuseOtelSpanAttributes.TRACE_TAGS]: tags,
+        [LangfuseOtelSpanAttributes.ENVIRONMENT]: environment,
+        [LangfuseOtelSpanAttributes.TRACE_PUBLIC]: isPublic,
+        ..._flattenAndSerializeMetadata(metadata, "trace"),
+    };
+    return Object.fromEntries(Object.entries(attributes).filter(([_, v]) => v != null));
+}
+export function createSpanAttributes({ metadata, input, output, level, statusMessage, version, }) {
+    const attributes = {
+        [LangfuseOtelSpanAttributes.OBSERVATION_TYPE]: "span",
+        [LangfuseOtelSpanAttributes.OBSERVATION_LEVEL]: level,
+        [LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,
+        [LangfuseOtelSpanAttributes.VERSION]: version,
+        [LangfuseOtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
+        [LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output),
+        ..._flattenAndSerializeMetadata(metadata, "observation"),
+    };
+    return Object.fromEntries(Object.entries(attributes).filter(([_, v]) => v != null));
+}
+export function createGenerationAttributes({ completionStartTime, metadata, level, statusMessage, version, model, modelParameters, input, output, usageDetails, costDetails, prompt, }) {
+    const attributes = {
+        [LangfuseOtelSpanAttributes.OBSERVATION_TYPE]: "generation",
+        [LangfuseOtelSpanAttributes.OBSERVATION_LEVEL]: level,
+        [LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,
+        [LangfuseOtelSpanAttributes.VERSION]: version,
+        [LangfuseOtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
+        [LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output),
+        [LangfuseOtelSpanAttributes.OBSERVATION_MODEL]: model,
+        [LangfuseOtelSpanAttributes.OBSERVATION_USAGE_DETAILS]: _serialize(usageDetails),
+        [LangfuseOtelSpanAttributes.OBSERVATION_COST_DETAILS]: _serialize(costDetails),
+        [LangfuseOtelSpanAttributes.OBSERVATION_COMPLETION_START_TIME]: _serialize(completionStartTime),
+        [LangfuseOtelSpanAttributes.OBSERVATION_MODEL_PARAMETERS]: _serialize(modelParameters),
+        ...(prompt && !prompt.isFallback
+            ? {
+                [LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_NAME]: prompt.name,
+                [LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_VERSION]: prompt.version,
+            }
+            : {}),
+        ..._flattenAndSerializeMetadata(metadata, "observation"),
+    };
+    return Object.fromEntries(Object.entries(attributes).filter(([_, v]) => v != null));
+}
+export function createEventAttributes({ metadata, input, output, level, statusMessage, version, }) {
+    const attributes = {
+        [LangfuseOtelSpanAttributes.OBSERVATION_TYPE]: "event",
+        [LangfuseOtelSpanAttributes.OBSERVATION_LEVEL]: level,
+        [LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,
+        [LangfuseOtelSpanAttributes.VERSION]: version,
+        [LangfuseOtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
+        [LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output),
+        ..._flattenAndSerializeMetadata(metadata, "observation"),
+    };
+    return Object.fromEntries(Object.entries(attributes).filter(([_, v]) => v != null));
+}
+function _serialize(obj) {
+    try {
+        return obj != null ? JSON.stringify(obj) : undefined;
+    }
+    catch {
+        return "<failed to serialize>";
+    }
+}
+function _flattenAndSerializeMetadata(metadata, type) {
+    const prefix = type === "observation"
+        ? LangfuseOtelSpanAttributes.OBSERVATION_METADATA
+        : LangfuseOtelSpanAttributes.TRACE_METADATA;
+    const metadataAttributes = {};
+    if (metadata === undefined || metadata === null) {
+        return metadataAttributes;
+    }
+    if (typeof metadata !== "object" || Array.isArray(metadata)) {
+        const serialized = _serialize(metadata);
+        if (serialized) {
+            metadataAttributes[prefix] = serialized;
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(metadata)) {
+            const serialized = typeof value === "string" ? value : _serialize(value);
+            if (serialized) {
+                metadataAttributes[`${prefix}.${key}`] = serialized;
+            }
+        }
+    }
+    return metadataAttributes;
+}

package/dist/index.cjs

@@ -0,0 +1,497 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LangfuseEvent: () => LangfuseEvent,
+  LangfuseGeneration: () => LangfuseGeneration,
+  LangfuseOtelSpanAttributes: () => import_core4.LangfuseOtelSpanAttributes,
+  LangfuseSpan: () => LangfuseSpan,
+  createEvent: () => createEvent,
+  createGenerationAttributes: () => createGenerationAttributes,
+  createSpanAttributes: () => createSpanAttributes,
+  createTraceAttributes: () => createTraceAttributes,
+  createTraceId: () => createTraceId,
+  observe: () => observe,
+  startActiveGeneration: () => startActiveGeneration,
+  startActiveSpan: () => startActiveSpan,
+  startGeneration: () => startGeneration,
+  startSpan: () => startSpan,
+  updateActiveGeneration: () => updateActiveGeneration,
+  updateActiveSpan: () => updateActiveSpan,
+  updateActiveTrace: () => updateActiveTrace
+});
+module.exports = __toCommonJS(index_exports);
+var import_core3 = require("@langfuse/core");
+var import_api2 = require("@opentelemetry/api");
+
+// src/attributes.ts
+var import_core = require("@langfuse/core");
+function createTraceAttributes({
+  name,
+  userId,
+  sessionId,
+  version,
+  release,
+  input,
+  output,
+  metadata,
+  tags,
+  environment,
+  public: isPublic
+} = {}) {
+  const attributes = {
+    [import_core.LangfuseOtelSpanAttributes.TRACE_NAME]: name,
+    [import_core.LangfuseOtelSpanAttributes.TRACE_USER_ID]: userId,
+    [import_core.LangfuseOtelSpanAttributes.TRACE_SESSION_ID]: sessionId,
+    [import_core.LangfuseOtelSpanAttributes.VERSION]: version,
+    [import_core.LangfuseOtelSpanAttributes.RELEASE]: release,
+    [import_core.LangfuseOtelSpanAttributes.TRACE_INPUT]: _serialize(input),
+    [import_core.LangfuseOtelSpanAttributes.TRACE_OUTPUT]: _serialize(output),
+    [import_core.LangfuseOtelSpanAttributes.TRACE_TAGS]: tags,
+    [import_core.LangfuseOtelSpanAttributes.ENVIRONMENT]: environment,
+    [import_core.LangfuseOtelSpanAttributes.TRACE_PUBLIC]: isPublic,
+    ..._flattenAndSerializeMetadata(metadata, "trace")
+  };
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([_, v]) => v != null)
+  );
+}
+function createSpanAttributes({
+  metadata,
+  input,
+  output,
+  level,
+  statusMessage,
+  version
+}) {
+  const attributes = {
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_TYPE]: "span",
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_LEVEL]: level,
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,
+    [import_core.LangfuseOtelSpanAttributes.VERSION]: version,
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output),
+    ..._flattenAndSerializeMetadata(metadata, "observation")
+  };
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([_, v]) => v != null)
+  );
+}
+function createGenerationAttributes({
+  completionStartTime,
+  metadata,
+  level,
+  statusMessage,
+  version,
+  model,
+  modelParameters,
+  input,
+  output,
+  usageDetails,
+  costDetails,
+  prompt
+}) {
+  const attributes = {
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_TYPE]: "generation",
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_LEVEL]: level,
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,
+    [import_core.LangfuseOtelSpanAttributes.VERSION]: version,
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output),
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_MODEL]: model,
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_USAGE_DETAILS]: _serialize(usageDetails),
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_COST_DETAILS]: _serialize(costDetails),
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_COMPLETION_START_TIME]: _serialize(completionStartTime),
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_MODEL_PARAMETERS]: _serialize(modelParameters),
+    ...prompt && !prompt.isFallback ? {
+      [import_core.LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_NAME]: prompt.name,
+      [import_core.LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_VERSION]: prompt.version
+    } : {},
+    ..._flattenAndSerializeMetadata(metadata, "observation")
+  };
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([_, v]) => v != null)
+  );
+}
+function createEventAttributes({
+  metadata,
+  input,
+  output,
+  level,
+  statusMessage,
+  version
+}) {
+  const attributes = {
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_TYPE]: "event",
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_LEVEL]: level,
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE]: statusMessage,
+    [import_core.LangfuseOtelSpanAttributes.VERSION]: version,
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_INPUT]: _serialize(input),
+    [import_core.LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT]: _serialize(output),
+    ..._flattenAndSerializeMetadata(metadata, "observation")
+  };
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([_, v]) => v != null)
+  );
+}
+function _serialize(obj) {
+  try {
+    return obj != null ? JSON.stringify(obj) : void 0;
+  } catch {
+    return "<failed to serialize>";
+  }
+}
+function _flattenAndSerializeMetadata(metadata, type) {
+  const prefix = type === "observation" ? import_core.LangfuseOtelSpanAttributes.OBSERVATION_METADATA : import_core.LangfuseOtelSpanAttributes.TRACE_METADATA;
+  const metadataAttributes = {};
+  if (metadata === void 0 || metadata === null) {
+    return metadataAttributes;
+  }
+  if (typeof metadata !== "object" || Array.isArray(metadata)) {
+    const serialized = _serialize(metadata);
+    if (serialized) {
+      metadataAttributes[prefix] = serialized;
+    }
+  } else {
+    for (const [key, value] of Object.entries(metadata)) {
+      const serialized = typeof value === "string" ? value : _serialize(value);
+      if (serialized) {
+        metadataAttributes[`${prefix}.${key}`] = serialized;
+      }
+    }
+  }
+  return metadataAttributes;
+}
+
+// src/utils.ts
+var import_core2 = require("@langfuse/core");
+var import_api = require("@opentelemetry/api");
+function getLangfuseTracer() {
+  return import_api.trace.getTracer(import_core2.LANGFUSE_TRACER_NAME, import_core2.LANGFUSE_SDK_VERSION);
+}
+
+// src/spanWrapper.ts
+var LangfuseSpanWrapper = class {
+  constructor(params) {
+    this.otelSpan = params.otelSpan;
+    this.id = params.otelSpan.spanContext().spanId;
+    this.traceId = params.otelSpan.spanContext().traceId;
+  }
+  get tracer() {
+    return getLangfuseTracer();
+  }
+  end(endTime) {
+    this.otelSpan.end(endTime);
+  }
+  updateTrace(attributes) {
+    this.otelSpan.setAttributes(createTraceAttributes(attributes));
+    return this;
+  }
+};
+var LangfuseSpan = class extends LangfuseSpanWrapper {
+  constructor(params) {
+    super(params);
+    if (params.attributes) {
+      this.otelSpan.setAttributes(createSpanAttributes(params.attributes));
+    }
+  }
+  update(attributes) {
+    this.otelSpan.setAttributes(createSpanAttributes(attributes));
+    return this;
+  }
+  startSpan(name, attributes) {
+    return startSpan(name, attributes, {
+      parentSpanContext: this.otelSpan.spanContext()
+    });
+  }
+  startGeneration(name, attributes) {
+    return startGeneration(name, attributes, {
+      parentSpanContext: this.otelSpan.spanContext()
+    });
+  }
+  createEvent(name, attributes) {
+    return createEvent(name, attributes, {
+      parentSpanContext: this.otelSpan.spanContext()
+    });
+  }
+};
+var LangfuseGeneration = class extends LangfuseSpanWrapper {
+  constructor(params) {
+    super(params);
+    if (params.attributes) {
+      this.otelSpan.setAttributes(
+        createGenerationAttributes(params.attributes)
+      );
+    }
+  }
+  update(attributes) {
+    this.otelSpan.setAttributes(createGenerationAttributes(attributes));
+    return this;
+  }
+  createEvent(name, attributes) {
+    return createEvent(name, attributes, {
+      parentSpanContext: this.otelSpan.spanContext()
+    });
+  }
+};
+var LangfuseEvent = class extends LangfuseSpanWrapper {
+  constructor(params) {
+    super(params);
+    if (params.attributes) {
+      this.otelSpan.setAttributes(createEventAttributes(params.attributes));
+    }
+    this.otelSpan.end(params.timestamp);
+  }
+};
+
+// src/index.ts
+var import_core4 = require("@langfuse/core");
+function createOtelSpan(params) {
+  return getLangfuseTracer().startSpan(
+    params.name,
+    { startTime: params.startTime },
+    createParentContext(params.parentSpanContext)
+  );
+}
+function createParentContext(parentSpanContext) {
+  if (!parentSpanContext) return;
+  return import_api2.trace.setSpanContext(import_api2.context.active(), parentSpanContext);
+}
+function wrapPromise(promise, span) {
+  return promise.then(
+    (value) => {
+      span.end();
+      return value;
+    },
+    (err) => {
+      span.setStatus({
+        code: import_api2.SpanStatusCode.ERROR,
+        message: err instanceof Error ? err.message : "Unknown error"
+      }).end();
+      throw err;
+    }
+  );
+}
+function startSpan(name, attributes, options) {
+  const otelSpan = createOtelSpan({
+    name,
+    ...options
+  });
+  return new LangfuseSpan({ otelSpan, attributes });
+}
+function startGeneration(name, attributes, options) {
+  const otelSpan = createOtelSpan({
+    name,
+    ...options
+  });
+  return new LangfuseGeneration({ otelSpan, attributes });
+}
+function createEvent(name, attributes, options) {
+  var _a;
+  const timestamp = (_a = options == null ? void 0 : options.startTime) != null ? _a : /* @__PURE__ */ new Date();
+  const otelSpan = createOtelSpan({
+    name,
+    ...options,
+    startTime: timestamp
+  });
+  return new LangfuseEvent({ otelSpan, attributes, timestamp });
+}
+function startActiveSpan(name, fn, options) {
+  var _a;
+  return getLangfuseTracer().startActiveSpan(
+    name,
+    { startTime: options == null ? void 0 : options.startTime },
+    (_a = createParentContext(options == null ? void 0 : options.parentSpanContext)) != null ? _a : import_api2.context.active(),
+    (span) => {
+      try {
+        const result = fn(new LangfuseSpan({ otelSpan: span }));
+        if (result instanceof Promise) {
+          return wrapPromise(result, span);
+        } else {
+          span.end();
+          return result;
+        }
+      } catch (err) {
+        span.setStatus({
+          code: import_api2.SpanStatusCode.ERROR,
+          message: err instanceof Error ? err.message : "Unknown error"
+        }).end();
+        throw err;
+      }
+    }
+  );
+}
+function startActiveGeneration(name, fn, options) {
+  var _a;
+  return getLangfuseTracer().startActiveSpan(
+    name,
+    { startTime: options == null ? void 0 : options.startTime },
+    (_a = createParentContext(options == null ? void 0 : options.parentSpanContext)) != null ? _a : import_api2.context.active(),
+    (span) => {
+      try {
+        const result = fn(new LangfuseGeneration({ otelSpan: span }));
+        if (result instanceof Promise) {
+          return wrapPromise(result, span);
+        } else {
+          span.end();
+          return result;
+        }
+      } catch (err) {
+        span.setStatus({
+          code: import_api2.SpanStatusCode.ERROR,
+          message: err instanceof Error ? err.message : "Unknown error"
+        }).end();
+        throw err;
+      }
+    }
+  );
+}
+function updateActiveTrace(attributes) {
+  const span = import_api2.trace.getActiveSpan();
+  if (!span) {
+    (0, import_core3.getGlobalLogger)().warn(
+      "No active OTEL span in context. Skipping trace update."
+    );
+    return;
+  }
+  span.setAttributes(createTraceAttributes(attributes));
+}
+function updateActiveSpan(attributes) {
+  const span = import_api2.trace.getActiveSpan();
+  if (!span) {
+    (0, import_core3.getGlobalLogger)().warn(
+      "No active OTEL span in context. Skipping span update."
+    );
+    return;
+  }
+  span.setAttributes(createSpanAttributes(attributes));
+}
+function updateActiveGeneration(attributes) {
+  const span = import_api2.trace.getActiveSpan();
+  if (!span) {
+    (0, import_core3.getGlobalLogger)().warn(
+      "No active OTEL span in context. Skipping generation update."
+    );
+    return;
+  }
+  span.setAttributes(createGenerationAttributes(attributes));
+}
+function observe(fn, options = {}) {
+  const {
+    name = fn.name || "anonymous-function",
+    asType = "span",
+    captureInput = true,
+    captureOutput = true
+  } = options;
+  const wrappedFunction = (...args) => {
+    const inputData = captureInput ? _captureArguments(args) : void 0;
+    const observation = asType === "generation" ? startGeneration(name, inputData ? { input: inputData } : {}) : startSpan(name, inputData ? { input: inputData } : {});
+    const activeContext = import_api2.trace.setSpan(import_api2.context.active(), observation.otelSpan);
+    try {
+      const result = import_api2.context.with(activeContext, () => fn(...args));
+      if (result instanceof Promise) {
+        return result.then(
+          (value) => {
+            if (captureOutput) {
+              observation.update({ output: _captureOutput(value) });
+            }
+            observation.end();
+            return value;
+          },
+          (error) => {
+            observation.update({
+              level: "ERROR",
+              statusMessage: (error instanceof Error ? error.message : String(error)) || "Function threw an error",
+              output: captureOutput ? { error: String(error) } : void 0
+            }).end();
+            throw error;
+          }
+        );
+      } else {
+        if (captureOutput) {
+          observation.update({ output: _captureOutput(result) });
+        }
+        observation.end();
+        return result;
+      }
+    } catch (error) {
+      observation.update({
+        level: "ERROR",
+        statusMessage: (error instanceof Error ? error.message : String(error)) || "Function threw an error",
+        output: captureOutput ? { error: String(error) } : void 0
+      }).end();
+      throw error;
+    }
+  };
+  return wrappedFunction;
+}
+function _captureArguments(args) {
+  try {
+    if (args.length === 0) return void 0;
+    if (args.length === 1) return args[0];
+    return args;
+  } catch {
+    return "<failed to capture arguments>";
+  }
+}
+function _captureOutput(value) {
+  try {
+    if (value === void 0 || value === null) return value;
+    if (typeof value !== "object") return value;
+    return value;
+  } catch {
+    return "<failed to capture output>";
+  }
+}
+async function createTraceId(seed) {
+  if (seed) {
+    const data = new TextEncoder().encode(seed);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    const hashArray = new Uint8Array(hashBuffer);
+    return uint8ArrayToHex(hashArray).slice(0, 32);
+  }
+  const randomValues = crypto.getRandomValues(new Uint8Array(16));
+  return uint8ArrayToHex(randomValues);
+}
+function uint8ArrayToHex(array) {
+  return Array.from(array).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LangfuseEvent,
+  LangfuseGeneration,
+  LangfuseOtelSpanAttributes,
+  LangfuseSpan,
+  createEvent,
+  createGenerationAttributes,
+  createSpanAttributes,
+  createTraceAttributes,
+  createTraceId,
+  observe,
+  startActiveGeneration,
+  startActiveSpan,
+  startGeneration,
+  startSpan,
+  updateActiveGeneration,
+  updateActiveSpan,
+  updateActiveTrace
+});
+//# sourceMappingURL=index.cjs.map