@langfuse/tracing 4.6.1 → 5.0.0-beta.0

package/dist/index.cjs

@@ -27,7 +27,7 @@ __export(index_exports, {
   LangfuseEvent: () => LangfuseEvent,
   LangfuseGeneration: () => LangfuseGeneration,
   LangfuseGuardrail: () => LangfuseGuardrail,
-  LangfuseOtelSpanAttributes: () => import_core5.LangfuseOtelSpanAttributes,
+  LangfuseOtelSpanAttributes: () => import_core6.LangfuseOtelSpanAttributes,
   LangfuseRetriever: () => LangfuseRetriever,
   LangfuseSpan: () => LangfuseSpan,
   LangfuseTool: () => LangfuseTool,
@@ -39,44 +39,27 @@ __export(index_exports, {
   getLangfuseTracer: () => getLangfuseTracer,
   getLangfuseTracerProvider: () => getLangfuseTracerProvider,
   observe: () => observe,
-  propagateAttributes: () => import_core4.propagateAttributes,
+  propagateAttributes: () => import_core5.propagateAttributes,
+  setActiveTraceAsPublic: () => setActiveTraceAsPublic,
+  setActiveTraceIO: () => setActiveTraceIO,
   setLangfuseTracerProvider: () => setLangfuseTracerProvider,
   startActiveObservation: () => startActiveObservation,
   startObservation: () => startObservation,
-  updateActiveObservation: () => updateActiveObservation,
-  updateActiveTrace: () => updateActiveTrace
+  updateActiveObservation: () => updateActiveObservation
 });
 module.exports = __toCommonJS(index_exports);
-var import_core3 = require("@langfuse/core");
+var import_core4 = 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
+  output
 } = {}) {
   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")
+    [import_core.LangfuseOtelSpanAttributes.TRACE_OUTPUT]: _serialize(output)
   };
   return Object.fromEntries(
     Object.entries(attributes).filter(([_, v]) => v != null)
@@ -149,6 +132,9 @@ function _flattenAndSerializeMetadata(metadata, type) {
   return metadataAttributes;
 }
 
+// src/spanWrapper.ts
+var import_core3 = require("@langfuse/core");
+
 // src/tracerProvider.ts
 var import_core2 = require("@langfuse/core");
 var import_api = require("@opentelemetry/api");
@@ -233,12 +219,53 @@ var LangfuseBaseObservation = class {
     );
   }
   /**
-   * Updates the parent trace with new attributes.
+   * Set trace-level input and output for the trace this observation belongs to.
+   *
+   * @deprecated This is a legacy method for backward compatibility with Langfuse platform
+   * features that still rely on trace-level input/output (e.g., legacy LLM-as-a-judge
+   * evaluators). It will be removed in a future major version.
+   *
+   * For setting other trace attributes (userId, sessionId, metadata, tags, version),
+   * use {@link propagateAttributes} instead.
+   *
+   * @param attributes - Input and output data to associate with the trace
+   * @returns The observation instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * const span = startObservation('my-operation');
+   * span.setTraceIO({
+   *   input: { query: 'user question' },
+   *   output: { response: 'assistant answer' }
+   * });
+   * ```
    */
-  updateTrace(attributes) {
+  setTraceIO(attributes) {
     this.otelSpan.setAttributes(createTraceAttributes(attributes));
     return this;
   }
+  /**
+   * Make the trace this observation belongs to publicly accessible via its URL.
+   *
+   * When a trace is published, anyone with the trace link can view the full trace
+   * without needing to be logged in to Langfuse. This action cannot be undone
+   * programmatically - once any span in a trace is published, the entire trace
+   * becomes public.
+   *
+   * @returns The observation instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * const span = startObservation('my-operation');
+   * span.setTraceAsPublic();
+   * ```
+   */
+  setTraceAsPublic() {
+    this.otelSpan.setAttributes({
+      [import_core3.LangfuseOtelSpanAttributes.TRACE_PUBLIC]: true
+    });
+    return this;
+  }
   startObservation(name, attributes, options) {
     const { asType = "span" } = options || {};
     return startObservation(name, attributes, {
@@ -445,8 +472,8 @@ var LangfuseEvent = class extends LangfuseBaseObservation {
 };
 
 // src/index.ts
-var import_core4 = require("@langfuse/core");
 var import_core5 = require("@langfuse/core");
+var import_core6 = require("@langfuse/core");
 function createOtelSpan(params) {
   return getLangfuseTracer().startSpan(
     params.name,
@@ -634,21 +661,33 @@ function startActiveObservation(name, fn, options) {
     }
   );
 }
-function updateActiveTrace(attributes) {
+function setActiveTraceIO(attributes) {
   const span = import_api2.trace.getActiveSpan();
   if (!span) {
-    (0, import_core3.getGlobalLogger)().warn(
-      "No active OTEL span in context. Skipping trace update."
+    (0, import_core4.getGlobalLogger)().warn(
+      "No active OTEL span in context. Skipping trace IO update."
     );
     return;
   }
   span.setAttributes(createTraceAttributes(attributes));
 }
+function setActiveTraceAsPublic() {
+  const span = import_api2.trace.getActiveSpan();
+  if (!span) {
+    (0, import_core4.getGlobalLogger)().warn(
+      "No active OTEL span in context. Skipping trace publish."
+    );
+    return;
+  }
+  span.setAttributes({
+    [import_core4.LangfuseOtelSpanAttributes.TRACE_PUBLIC]: true
+  });
+}
 function updateActiveObservation(attributes, options) {
   var _a;
   const span = import_api2.trace.getActiveSpan();
   if (!span) {
-    (0, import_core3.getGlobalLogger)().warn(
+    (0, import_core4.getGlobalLogger)().warn(
       "No active OTEL span in context. Skipping span update."
     );
     return;
@@ -658,7 +697,7 @@ function updateActiveObservation(attributes, options) {
     attributes
   );
   if (!(options == null ? void 0 : options.asType)) {
-    otelAttributes[import_core3.LangfuseOtelSpanAttributes.OBSERVATION_TYPE] = void 0;
+    otelAttributes[import_core4.LangfuseOtelSpanAttributes.OBSERVATION_TYPE] = void 0;
   }
   span.setAttributes(otelAttributes);
 }
@@ -791,10 +830,11 @@ function getActiveSpanId() {
   getLangfuseTracerProvider,
   observe,
   propagateAttributes,
+  setActiveTraceAsPublic,
+  setActiveTraceIO,
   setLangfuseTracerProvider,
   startActiveObservation,
   startObservation,
-  updateActiveObservation,
-  updateActiveTrace
+  updateActiveObservation
 });
 //# sourceMappingURL=index.cjs.map