push

Author: hassiebp

langfuse/_client/attributes.py

@@ -12,7 +12,7 @@
 
 import json
 from datetime import datetime
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Dict, Literal, Optional, Union
 
 from langfuse._client.constants import (
     ObservationTypeGenerationLike,
@@ -74,28 +74,14 @@ class LangfuseOtelSpanAttributes:
 
 def create_trace_attributes(
     *,
-    name: Optional[str] = None,
-    user_id: Optional[str] = None,
-    session_id: Optional[str] = None,
-    version: Optional[str] = None,
-    release: Optional[str] = None,
     input: Optional[Any] = None,
     output: Optional[Any] = None,
-    metadata: Optional[Any] = None,
-    tags: Optional[List[str]] = None,
     public: Optional[bool] = None,
 ) -> dict:
     attributes = {
-        LangfuseOtelSpanAttributes.TRACE_NAME: name,
-        LangfuseOtelSpanAttributes.TRACE_USER_ID: user_id,
-        LangfuseOtelSpanAttributes.TRACE_SESSION_ID: session_id,
-        LangfuseOtelSpanAttributes.VERSION: version,
-        LangfuseOtelSpanAttributes.RELEASE: release,
         LangfuseOtelSpanAttributes.TRACE_INPUT: _serialize(input),
         LangfuseOtelSpanAttributes.TRACE_OUTPUT: _serialize(output),
-        LangfuseOtelSpanAttributes.TRACE_TAGS: tags,
         LangfuseOtelSpanAttributes.TRACE_PUBLIC: public,
-        **_flatten_and_serialize_metadata(metadata, "trace"),
     }
 
     return {k: v for k, v in attributes.items() if v is not None}

langfuse/_client/client.py

@@ -35,6 +35,7 @@
     _agnosticcontextmanager,
 )
 from packaging.version import Version
+from typing_extensions import deprecated
 
 from langfuse._client.attributes import LangfuseOtelSpanAttributes, _serialize
 from langfuse._client.constants import (
@@ -1633,6 +1634,89 @@ def update_current_span(
                 status_message=status_message,
             )
 
+    @deprecated(
+        "Trace-level input/output is deprecated. "
+        "For trace attributes (user_id, session_id, tags, etc.), use propagate_attributes() instead. "
+        "This method will be removed in a future major version."
+    )
+    def set_current_trace_io(
+        self,
+        *,
+        input: Optional[Any] = None,
+        output: Optional[Any] = None,
+    ) -> None:
+        """Set trace-level input and output for the current span's trace.
+
+        .. 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 (user_id, session_id, metadata, tags, version),
+            use :meth:`propagate_attributes` instead.
+
+        Args:
+            input: Input data to associate with the trace.
+            output: Output data to associate with the trace.
+        """
+        if not self._tracing_enabled:
+            langfuse_logger.debug(
+                "Operation skipped: set_current_trace_io - Tracing is disabled or client is in no-op mode."
+            )
+            return
+
+        current_otel_span = self._get_current_otel_span()
+
+        if current_otel_span is not None and current_otel_span.is_recording():
+            existing_observation_type = current_otel_span.attributes.get(  # type: ignore[attr-defined]
+                LangfuseOtelSpanAttributes.OBSERVATION_TYPE, "span"
+            )
+            # We need to preserve the class to keep the correct observation type
+            span_class = self._get_span_class(existing_observation_type)
+            span = span_class(
+                otel_span=current_otel_span,
+                langfuse_client=self,
+                environment=self._environment,
+            )
+
+            span.set_trace_io(
+                input=input,
+                output=output,
+            )
+
+    def publish_current_trace(self) -> None:
+        """Make the current trace 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 published, the entire trace becomes public.
+
+        This is a convenience method that publishes the trace from the currently
+        active span context. Use this when you want to make a trace public from
+        within a traced function without needing direct access to the span object.
+        """
+        if not self._tracing_enabled:
+            langfuse_logger.debug(
+                "Operation skipped: publish_current_trace - Tracing is disabled or client is in no-op mode."
+            )
+            return
+
+        current_otel_span = self._get_current_otel_span()
+
+        if current_otel_span is not None and current_otel_span.is_recording():
+            existing_observation_type = current_otel_span.attributes.get(  # type: ignore[attr-defined]
+                LangfuseOtelSpanAttributes.OBSERVATION_TYPE, "span"
+            )
+            # We need to preserve the class to keep the correct observation type
+            span_class = self._get_span_class(existing_observation_type)
+            span = span_class(
+                otel_span=current_otel_span,
+                langfuse_client=self,
+                environment=self._environment,
+            )
+
+            span.publish_trace()
+
     def create_event(
         self,
         *,

langfuse/_client/span.py

@@ -37,10 +37,13 @@
 if TYPE_CHECKING:
     from langfuse._client.client import Langfuse
 
+from typing_extensions import deprecated
+
 from langfuse._client.attributes import (
     LangfuseOtelSpanAttributes,
     create_generation_attributes,
     create_span_attributes,
+    create_trace_attributes,
 )
 from langfuse._client.constants import (
     ObservationTypeGenerationLike,
@@ -207,6 +210,73 @@ def end(self, *, end_time: Optional[int] = None) -> "LangfuseObservationWrapper"
 
         return self
 
+    @deprecated(
+        "Trace-level input/output is deprecated. "
+        "For trace attributes (user_id, session_id, tags, etc.), use propagate_attributes() instead. "
+        "This method will be removed in a future major version."
+    )
+    def set_trace_io(
+        self,
+        *,
+        input: Optional[Any] = None,
+        output: Optional[Any] = None,
+    ) -> "LangfuseObservationWrapper":
+        """Set trace-level input and output for the trace this span 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 (user_id, session_id, metadata, tags, version),
+            use :meth:`Langfuse.propagate_attributes` instead.
+
+        Args:
+            input: Input data to associate with the trace.
+            output: Output data to associate with the trace.
+
+        Returns:
+            The span instance for method chaining.
+        """
+        if not self._otel_span.is_recording():
+            return self
+
+        media_processed_input = self._process_media_and_apply_mask(
+            data=input, field="input", span=self._otel_span
+        )
+        media_processed_output = self._process_media_and_apply_mask(
+            data=output, field="output", span=self._otel_span
+        )
+
+        attributes = create_trace_attributes(
+            input=media_processed_input,
+            output=media_processed_output,
+        )
+
+        self._otel_span.set_attributes(attributes)
+
+        return self
+
+    def publish_trace(self) -> "LangfuseObservationWrapper":
+        """Make this trace 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 span instance for method chaining.
+        """
+        if not self._otel_span.is_recording():
+            return self
+
+        attributes = create_trace_attributes(public=True)
+
+        self._otel_span.set_attributes(attributes)
+
+        return self
+
     @overload
     def score(
         self,

tests/test_batch_evaluation.py

@@ -10,7 +10,7 @@
 
 import pytest
 
-from langfuse import get_client
+from langfuse import get_client, propagate_attributes
 from langfuse.batch_evaluation import (
     BatchEvaluationResult,
     BatchEvaluationResumeToken,
@@ -100,11 +100,11 @@ def test_batch_evaluation_with_filter(langfuse_client):
     with langfuse_client.start_as_current_span(
         name=f"filtered-trace-{create_uuid()}"
     ) as span:
-        span.update_trace(
-            input="Filtered test",
-            output="Filtered output",
-            tags=[unique_tag],
-        )
+        with propagate_attributes(tags=[unique_tag]):
+            span.set_trace_io(
+                input="Filtered test",
+                output="Filtered output",
+            )
 
     langfuse_client.flush()
     time.sleep(3)
@@ -728,11 +728,11 @@ def test_pagination_with_max_items(langfuse_client):
         with langfuse_client.start_as_current_span(
             name=f"pagination-test-{create_uuid()}"
         ) as span:
-            span.update_trace(
-                input=f"Input {i}",
-                output=f"Output {i}",
-                tags=["pagination_test"],
-            )
+            with propagate_attributes(tags=["pagination_test"]):
+                span.set_trace_io(
+                    input=f"Input {i}",
+                    output=f"Output {i}",
+                )
 
     langfuse_client.flush()
     time.sleep(3)
@@ -758,11 +758,11 @@ def test_has_more_items_flag(langfuse_client):
     batch_tag = f"batch-test-{create_uuid()}"
     for i in range(15):
         with langfuse_client.start_as_current_span(name=f"more-items-test-{i}") as span:
-            span.update_trace(
-                input=f"Input {i}",
-                output=f"Output {i}",
-                tags=[batch_tag],
-            )
+            with propagate_attributes(tags=[batch_tag]):
+                span.set_trace_io(
+                    input=f"Input {i}",
+                    output=f"Output {i}",
+                )
 
     langfuse_client.flush()
     time.sleep(3)