langfuse-haystack 4.1.0__tar.gz → 5.0.1__tar.gz

{langfuse_haystack-4.1.0 → langfuse_haystack-5.0.1}/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [integrations/langfuse-v5.0.0] - 2026-04-17
+
+### 🚀 Features
+
+- [**breaking**] Migrate to Langfuse Python SDK v4 (#3126)
+
+### 🧪 Testing
+
+- Track test coverage for all integrations (#3065)
+
+
+## [integrations/langfuse-v4.1.0] - 2026-03-26
+
+### 🚀 Features
+
+- Log generation_kwargs in Langfuse spans (#3017)
+
+### 🐛 Bug Fixes
+
+- *(langfuse)* Replace MagicMock with Mock to prevent RAM exhaustion (#2543) (#2798)
+
+### 📚 Documentation
+
+- Simplify pydoc configs (#2855)
+
+### 🧹 Chores
+
+- Remove unused allow-direct-references (#2866)
+- Add ANN type annotations to google_genai, hanlp, jina, langfuse, lara (#2990)
+- Enforce ruff docstring rules (D102/D103/D205/D209/D213/D417/D419) in integrations 21-30 (#3010)
+
+
 ## [integrations/langfuse-v4.0.1] - 2026-01-27
 
 ### 🐛 Bug Fixes

{langfuse_haystack-4.1.0 → langfuse_haystack-5.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfuse-haystack
-Version: 4.1.0
+Version: 5.0.1
 Summary: Langfuse integration for Haystack
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
 Requires-Dist: haystack-ai>=2.22.0
-Requires-Dist: langfuse<4.0.0,>=3.3.1
+Requires-Dist: langfuse>=4.0.0
 Description-Content-Type: text/markdown
 
 # langfuse-haystack

{langfuse_haystack-4.1.0 → langfuse_haystack-5.0.1}/pyproject.toml

@@ -21,7 +21,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.22.0", "langfuse>=3.3.1, <4.0.0"]
+dependencies = ["haystack-ai>=2.22.0", "langfuse>=4.0.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse#readme"
@@ -66,7 +66,8 @@ dependencies = [
 unit = 'pytest -m "not integration" {args:tests}'
 integration = 'pytest -m "integration" {args:tests}'
 all = 'pytest {args:tests}'
-cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x {args:tests}'
+unit-cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x -m "not integration" {args:tests}'
+integration-cov-append-retry = 'pytest --cov=haystack_integrations --cov-append --reruns 3 --reruns-delay 30 -x -m "integration" {args:tests}'
 
 types = "mypy -p haystack_integrations.components.connectors.langfuse -p haystack_integrations.tracing.langfuse {args}"
 
@@ -152,6 +153,7 @@ ban-relative-imports = "parents"
 [tool.coverage.run]
 source = ["haystack_integrations"]
 branch = true
+relative_files = true
 parallel = false
 
 
@@ -159,6 +161,8 @@ parallel = false
 omit = ["*/tests/*", "*/__init__.py"]
 show_missing = true
 exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
+# coverage automatically detects some of the test dependencies but cannot find the source, so we ignore the errors
+ignore_errors = true
 
 [tool.pytest.ini_options]
 addopts = "--strict-markers"

{langfuse_haystack-4.1.0 → langfuse_haystack-5.0.1}/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -22,7 +22,8 @@ from haystack.tracing import utils as tracing_utils
 
 import langfuse
 from langfuse import LangfuseSpan as LangfuseClientSpan
-from langfuse.types import TraceContext, TraceMetadata
+from langfuse import propagate_attributes
+from langfuse.types import TraceContext
 
 logger = logging.getLogger(__name__)
 
@@ -61,7 +62,6 @@ class LangfuseSpan(Span):
         Initialize a LangfuseSpan instance.
 
         :param context_manager: The context manager from Langfuse created with
-        `langfuse.get_client().start_as_current_span` or
         `langfuse.get_client().start_as_current_observation`.
         """
         self._span = context_manager.__enter__()
@@ -90,7 +90,7 @@ class LangfuseSpan(Span):
             return
         if key.endswith(".input"):
             if "messages" in value:
-                messages = [m.to_openai_dict_format(require_tool_call_ids=False) for m in value["messages"]]
+                messages = [m.to_openai_dict_format(require_tool_call_ids=False) for m in (value.get("messages") or [])]
                 if isinstance(gen_kwargs := value.get("generation_kwargs"), dict):
                     self._span.update(input={"messages": messages, "generation_kwargs": gen_kwargs})
                 else:
@@ -100,10 +100,11 @@ class LangfuseSpan(Span):
                 self._span.update(input=coerced_value)
         elif key.endswith(".output"):
             if "replies" in value:
-                if all(isinstance(r, ChatMessage) for r in value["replies"]):
-                    replies = [m.to_openai_dict_format(require_tool_call_ids=False) for m in value["replies"]]
+                replies_list = value.get("replies") or []
+                if all(isinstance(r, ChatMessage) for r in replies_list):
+                    replies = [m.to_openai_dict_format(require_tool_call_ids=False) for m in replies_list]
                 else:
-                    replies = value["replies"]
+                    replies = replies_list
                 self._span.update(output=replies)
             else:
                 coerced_value = tracing_utils.coerce_tag_value(value)
@@ -297,33 +298,17 @@ class DefaultSpanHandler(SpanHandler):
             trace_context: TraceContext | None = cast(
                 TraceContext, {"trace_id": tracing_ctx.get("trace_id")} if tracing_ctx.get("trace_id") else None
             )
-            # Create a new trace when there's no parent span
+
             span_context_manager = self.tracer.start_as_current_observation(
                 trace_context=trace_context,
                 name=context.trace_name,
                 version=tracing_ctx.get("version"),
                 as_type=root_span_type,
             )
-
-            # Create LangfuseSpan which will handle entering the context manager
             span = LangfuseSpan(span_context_manager)
 
-            # Build trace metadata from context
-            trace_metadata: TraceMetadata = {
-                "name": context.trace_name,
-                "user_id": tracing_ctx.get("user_id"),
-                "session_id": tracing_ctx.get("session_id"),
-                "version": tracing_ctx.get("version"),
-                "metadata": None,
-                "tags": tracing_ctx.get("tags"),
-                "public": context.public,
-                "release": None,
-            }
-
-            # Filter out None values and apply trace attributes
-            trace_attrs = {k: v for k, v in trace_metadata.items() if v is not None}
-            if trace_attrs:
-                span._span.update_trace(**trace_attrs)
+            if context.public:
+                span.raw_span().set_trace_as_public()
 
             return span
 
@@ -347,7 +332,7 @@ class DefaultSpanHandler(SpanHandler):
                 )
             )
         else:
-            return LangfuseSpan(self.tracer.start_as_current_span(name=context.name))
+            return LangfuseSpan(self.tracer.start_as_current_observation(name=context.name))
 
     def handle(self, span: LangfuseSpan, component_type: str | None) -> None:
         """Process and enrich a span after component execution."""
@@ -356,7 +341,7 @@ class DefaultSpanHandler(SpanHandler):
         if at_pipeline_level:
             coerced_input = tracing_utils.coerce_tag_value(span.get_data().get(_PIPELINE_INPUT_KEY))
             coerced_output = tracing_utils.coerce_tag_value(span.get_data().get(_PIPELINE_OUTPUT_KEY))
-            span.raw_span().update_trace(input=coerced_input, output=coerced_output)
+            span.raw_span().update(input=coerced_input, output=coerced_output)
         # special case for ToolInvoker (to update the span name to be: `original_component_name - [tool_names]`)
         if component_type == "ToolInvoker":
             tool_names: list[str] = []
@@ -468,6 +453,7 @@ class LangfuseTracer(Tracer):
         tags = tags or {}
         span_name = tags.get(_COMPONENT_NAME_KEY, operation_name)
         component_type = tags.get(_COMPONENT_TYPE_KEY)
+        is_root_span = not (parent_span or self.current_span())
 
         # Create a new span context
         span_context = SpanContext(
@@ -482,74 +468,91 @@ class LangfuseTracer(Tracer):
             public=self._public,
         )
 
-        # Create span using the handler
-        span = self._span_handler.create_span(span_context)
+        tracing_ctx = tracing_context_var.get({})
 
-        # Build new span hierarchy: copy existing stack, add new span, save for restoration
-        prev_stack = span_stack_var.get()
-        new_stack = (prev_stack or []).copy()
-        new_stack.append(span)
-        token = span_stack_var.set(new_stack)
+        # we need to properly exit context managers
+        with contextlib.ExitStack() as stack:
+            if is_root_span:
+                # propagate_attributes sets trace_name and other trace-level metadata on the root
+                # span and ALL child spans created within this context (full trace lifetime)
+                stack.enter_context(
+                    propagate_attributes(
+                        trace_name=self._name,
+                        user_id=tracing_ctx.get("user_id") if tracing_ctx.get("user_id") is not None else None,
+                        session_id=tracing_ctx.get("session_id") if tracing_ctx.get("session_id") is not None else None,
+                        version=tracing_ctx.get("version") if tracing_ctx.get("version") is not None else None,
+                        tags=tracing_ctx.get("tags") if tracing_ctx.get("tags") is not None else None,
+                    )
+                )
 
-        span.set_tags(tags)
+            # Create span using the handler
+            span = self._span_handler.create_span(span_context)
 
-        try:
-            yield span
-        except Exception:
-            # Exception occurred - capture exception info and pass to __exit__
-            # This allows Langfuse/OpenTelemetry to properly mark the span with ERROR level
-            exc_info = sys.exc_info()
-            try:
-                # Process span data (may fail with nested pipeline exceptions)
-                self._span_handler.handle(span, component_type)
-
-                # End span with exception info (may fail if span data is corrupted)
-                raw_span = span.raw_span()
-                if span._context_manager is not None:
-                    # Pass actual exception info to mark span as failed with ERROR level
-                    span._context_manager.__exit__(*exc_info)
-                elif hasattr(raw_span, "end"):
-                    # Only call end() if it's not a context manager
-                    raw_span.end()
-            except Exception as cleanup_error:
-                # Log cleanup errors but don't let them corrupt context
-                logger.warning(
-                    "Error during span cleanup for {operation_name}: {cleanup_error}",
-                    operation_name=operation_name,
-                    cleanup_error=cleanup_error,
-                )
+            # Build new span hierarchy: copy existing stack, add new span, save for restoration
+            prev_stack = span_stack_var.get()
+            new_stack = (prev_stack or []).copy()
+            new_stack.append(span)
+            token = span_stack_var.set(new_stack)
 
-            # Re-raise the original exception
-            raise
-        else:
-            # No exception - clean exit with success status
-            # This preserves any manually-set log levels (WARNING, DEBUG)
-            try:
-                # Process span data
-                self._span_handler.handle(span, component_type)
-
-                # End span successfully
-                raw_span = span.raw_span()
-                # In v3, we need to properly exit context managers
-                if span._context_manager is not None:
-                    # No exception - pass None to indicate success
-                    span._context_manager.__exit__(None, None, None)
-                elif hasattr(raw_span, "end"):
-                    # Only call end() if it's not a context manager
-                    raw_span.end()
-            except Exception as cleanup_error:
-                # Log cleanup errors but don't let them corrupt context
-                logger.warning(
-                    "Error during span cleanup for {operation_name}: {cleanup_error}",
-                    operation_name=operation_name,
-                    cleanup_error=cleanup_error,
-                )
-        finally:
-            # Restore previous span stack using saved token
-            span_stack_var.reset(token)
+            span.set_tags(tags)
 
-            if self.enforce_flush:
-                self.flush()
+            try:
+                yield span
+            except Exception:
+                # Exception occurred - capture exception info and pass to __exit__
+                # This allows Langfuse/OpenTelemetry to properly mark the span with ERROR level
+                exc_info = sys.exc_info()
+                try:
+                    # Process span data (may fail with nested pipeline exceptions)
+                    self._span_handler.handle(span, component_type)
+
+                    # End span with exception info (may fail if span data is corrupted)
+                    raw_span = span.raw_span()
+                    if span._context_manager is not None:
+                        # Pass actual exception info to mark span as failed with ERROR level
+                        span._context_manager.__exit__(*exc_info)
+                    elif hasattr(raw_span, "end"):
+                        # Only call end() if it's not a context manager
+                        raw_span.end()
+                except Exception as cleanup_error:
+                    # Log cleanup errors but don't let them corrupt context
+                    logger.warning(
+                        "Error during span cleanup for {operation_name}: {cleanup_error}",
+                        operation_name=operation_name,
+                        cleanup_error=cleanup_error,
+                    )
+
+                # Re-raise the original exception
+                raise
+            else:
+                # No exception - clean exit with success status
+                # This preserves any manually-set log levels (WARNING, DEBUG)
+                try:
+                    # Process span data
+                    self._span_handler.handle(span, component_type)
+
+                    # End span successfully
+                    raw_span = span.raw_span()
+                    # In v3, we need to properly exit context managers
+                    if span._context_manager is not None:
+                        # No exception - pass None to indicate success
+                        span._context_manager.__exit__(None, None, None)
+                    elif hasattr(raw_span, "end"):
+                        # Only call end() if it's not a context manager
+                        raw_span.end()
+                except Exception as cleanup_error:
+                    # Log cleanup errors but don't let them corrupt context
+                    logger.warning(
+                        "Error during span cleanup for {operation_name}: {cleanup_error}",
+                        operation_name=operation_name,
+                        cleanup_error=cleanup_error,
+                    )
+            finally:
+                # Restore previous span stack using saved token
+                span_stack_var.reset(token)
+
+                if self.enforce_flush:
+                    self.flush()
 
     def flush(self) -> None:
         """Flush all pending spans to Langfuse."""

{langfuse_haystack-4.1.0 → langfuse_haystack-5.0.1}/tests/test_tracer.py

@@ -22,17 +22,15 @@ from haystack_integrations.tracing.langfuse.tracer import (
 )
 
 
-# Mock functions for Langfuse v3 API
 def mock_get_client():
     mock_client = Mock()
-    mock_client.start_as_current_span = Mock(return_value=MockContextManager())
     mock_client.start_as_current_observation = Mock(return_value=MockContextManager())
     mock_client.get_current_trace_id = Mock(return_value="mock_trace_id_123")
     return mock_client
 
 
 class MockContextManager:
-    """Mock context manager that simulates Langfuse v3 context managers"""
+    """Mock context manager that simulates Langfuse v4 context managers"""
 
     def __init__(self, name="mock_span"):
         self._span = MockSpan(name)
@@ -63,9 +61,8 @@ class MockSpan:
         # Return a new mock span for child spans
         return MockSpan(name=name or "child_span")
 
-    def update_trace(self, **kwargs):
-        # v3 API method for updating trace-level data
-        self._data.update(kwargs)
+    def set_trace_as_public(self):
+        self._data["public"] = True
 
     def generation(self, name=None):
         # Return a new mock span for generation spans
@@ -90,9 +87,6 @@ class MockLangfuseClient:
     def __init__(self):
         self._mock_context_manager = MockContextManager()
 
-    def start_as_current_span(self, _name=None, **_kwargs):
-        return self._mock_context_manager
-
     def start_as_current_observation(self, _name=None, _as_type=None, **_kwargs):
         return self._mock_context_manager
 
@@ -134,57 +128,75 @@ class TestLangfuseSpan:
     #  set_content_tag method can update input and output of the span object
     def test_set_content_tag_updates_input_and_output(self):
         mock_context_manager = MockContextManager()
-
         span = LangfuseSpan(mock_context_manager)
-        span.set_content_tag("test.input", "input_value")
-        # Check that the span.update method was called with input parameter
-        mock_context_manager._span.update.assert_called_with(input="input_value")
 
-        mock_context_manager._span.update.reset_mock()
-        span.set_content_tag("test.output", "output_value")
-        # Check that the span.update method was called with output parameter
-        mock_context_manager._span.update.assert_called_with(output="output_value")
+        with patch("haystack_integrations.tracing.langfuse.tracer.proxy_tracer.is_content_tracing_enabled", True):
+            span.set_content_tag("test.input", "input_value")
+            mock_context_manager._span.update.assert_called_with(input="input_value")
+
+            mock_context_manager._span.update.reset_mock()
+            span.set_content_tag("test.output", "output_value")
+            mock_context_manager._span.update.assert_called_with(output="output_value")
 
     # set_content_tag method can update input and output of the span object with messages/replies
     def test_set_content_tag_updates_input_and_output_with_messages(self):
         mock_context_manager = MockContextManager()
-
         span = LangfuseSpan(mock_context_manager)
-        span.set_content_tag("key.input", {"messages": [ChatMessage.from_user("message")]})
-        assert mock_context_manager._span.update.call_count == 1
-        # check we converted ChatMessage to OpenAI format
-        assert mock_context_manager._span.update.call_args_list[0][1] == {
-            "input": [{"role": "user", "content": "message"}]
-        }
 
-        # test generation_kwargs are captured
-        mock_context_manager._span.update.reset_mock()
-        span.set_content_tag(
-            "key.input",
-            {"messages": [ChatMessage.from_user("message")], "generation_kwargs": {"n": 2, "temperature": 0.7}},
-        )
-        assert mock_context_manager._span.update.call_count == 1
-        assert mock_context_manager._span.update.call_args_list[0][1] == {
-            "input": {
-                "messages": [{"role": "user", "content": "message"}],
-                "generation_kwargs": {"n": 2, "temperature": 0.7},
+        with patch("haystack_integrations.tracing.langfuse.tracer.proxy_tracer.is_content_tracing_enabled", True):
+            span.set_content_tag("key.input", {"messages": [ChatMessage.from_user("message")]})
+            assert mock_context_manager._span.update.call_count == 1
+            # check we converted ChatMessage to OpenAI format
+            assert mock_context_manager._span.update.call_args_list[0][1] == {
+                "input": [{"role": "user", "content": "message"}]
             }
-        }
-        # test replies ChatMessage list
-        mock_context_manager._span.update.reset_mock()
-        span.set_content_tag("key.output", {"replies": [ChatMessage.from_system("reply")]})
-        assert mock_context_manager._span.update.call_count == 1
-        # check we converted ChatMessage to OpenAI format
-        assert mock_context_manager._span.update.call_args_list[0][1] == {
-            "output": [{"role": "system", "content": "reply"}]
-        }
 
-        # test replies string list
-        mock_context_manager._span.update.reset_mock()
-        span.set_content_tag("key.output", {"replies": ["reply1", "reply2"]})
-        assert mock_context_manager._span.update.call_count == 1
-        # check we handle properly string list replies
-        assert mock_context_manager._span.update.call_args_list[0][1] == {"output": ["reply1", "reply2"]}
+            # test generation_kwargs are captured
+            mock_context_manager._span.update.reset_mock()
+            span.set_content_tag(
+                "key.input",
+                {"messages": [ChatMessage.from_user("message")], "generation_kwargs": {"n": 2, "temperature": 0.7}},
+            )
+            assert mock_context_manager._span.update.call_count == 1
+            assert mock_context_manager._span.update.call_args_list[0][1] == {
+                "input": {
+                    "messages": [{"role": "user", "content": "message"}],
+                    "generation_kwargs": {"n": 2, "temperature": 0.7},
+                }
+            }
+            # test replies ChatMessage list
+            mock_context_manager._span.update.reset_mock()
+            span.set_content_tag("key.output", {"replies": [ChatMessage.from_system("reply")]})
+            assert mock_context_manager._span.update.call_count == 1
+            # check we converted ChatMessage to OpenAI format
+            assert mock_context_manager._span.update.call_args_list[0][1] == {
+                "output": [{"role": "system", "content": "reply"}]
+            }
+
+            # test replies string list
+            mock_context_manager._span.update.reset_mock()
+            span.set_content_tag("key.output", {"replies": ["reply1", "reply2"]})
+            assert mock_context_manager._span.update.call_count == 1
+            # check we handle properly string list replies
+            assert mock_context_manager._span.update.call_args_list[0][1] == {"output": ["reply1", "reply2"]}
+
+    def test_set_content_tag_messages_none_does_not_raise(self):
+        mock_context_manager = MockContextManager()
+        span = LangfuseSpan(mock_context_manager)
+
+        with patch("haystack_integrations.tracing.langfuse.tracer.proxy_tracer.is_content_tracing_enabled", True):
+            span.set_content_tag("key.input", {"messages": None})
+            assert mock_context_manager._span.update.call_count == 1
+            assert mock_context_manager._span.update.call_args_list[0][1] == {"input": []}
+
+    def test_set_content_tag_replies_none_does_not_raise(self):
+        mock_context_manager = MockContextManager()
+        span = LangfuseSpan(mock_context_manager)
+
+        with patch("haystack_integrations.tracing.langfuse.tracer.proxy_tracer.is_content_tracing_enabled", True):
+            span.set_content_tag("key.output", {"replies": None})
+            assert mock_context_manager._span.update.call_count == 1
+            assert mock_context_manager._span.update.call_args_list[0][1] == {"output": []}
 
 
 class TestSpanContext:
@@ -239,7 +251,6 @@ class TestDefaultSpanHandler:
     def test_create_span_root_trace(self):
         """Test creating a root span (no parent)."""
         mock_client = Mock()
-        mock_client.start_as_current_span = Mock(return_value=MockContextManager())
         mock_client.start_as_current_observation = Mock(return_value=MockContextManager())
 
         handler = DefaultSpanHandler()
@@ -274,6 +285,24 @@ class TestDefaultSpanHandler:
         finally:
             tracing_context_var.reset(token)
 
+    def test_create_span_root_trace_public(self):
+        """Test that public=True calls set_trace_as_public on the span."""
+        mock_client = Mock()
+        mock_client.start_as_current_observation = Mock(return_value=MockContextManager())
+
+        handler = DefaultSpanHandler()
+        handler.init_tracer(mock_client)
+
+        context = MagicMock(spec=SpanContext)
+        context.parent_span = None
+        context.trace_name = "public_trace"
+        context.operation_name = "haystack.pipeline.run"
+        context.public = True
+
+        result = handler.create_span(context)
+
+        assert result.raw_span()._data.get("public") is True
+
     def test_handle_generator(self):
         mock_span = Mock()
         mock_span.raw_span.return_value = mock_span
@@ -345,7 +374,6 @@ class TestDefaultSpanHandler:
     def test_create_span_custom_chat_generator(self):
         """Test that custom chat generators create 'generation' span type."""
         mock_client = Mock()
-        mock_client.start_as_current_span = Mock(return_value=MockContextManager())
         mock_client.start_as_current_observation = Mock(return_value=MockContextManager())
 
         handler = DefaultSpanHandler()
@@ -356,8 +384,9 @@ class TestDefaultSpanHandler:
             operation_name="haystack.component.run",
             component_type="MistralChatGenerator",
             tags={},
-            parent_span=LangfuseSpan(mock_client.start_as_current_span()),
+            parent_span=LangfuseSpan(mock_client.start_as_current_observation()),
         )
+        mock_client.start_as_current_observation.reset_mock()
 
         span = handler.create_span(context)
         assert isinstance(span, LangfuseSpan)
@@ -368,7 +397,6 @@ class TestDefaultSpanHandler:
     def test_create_span_custom_generator(self):
         """Test that custom generators create 'generation' span type."""
         mock_client = Mock()
-        mock_client.start_as_current_span = Mock(return_value=MockContextManager())
         mock_client.start_as_current_observation = Mock(return_value=MockContextManager())
 
         handler = DefaultSpanHandler()
@@ -379,8 +407,9 @@ class TestDefaultSpanHandler:
             operation_name="haystack.component.run",
             component_type="CustomAPIGenerator",
             tags={},
-            parent_span=LangfuseSpan(mock_client.start_as_current_span()),
+            parent_span=LangfuseSpan(mock_client.start_as_current_observation()),
         )
+        mock_client.start_as_current_observation.reset_mock()
 
         span = handler.create_span(context)
         assert isinstance(span, LangfuseSpan)
@@ -391,7 +420,6 @@ class TestDefaultSpanHandler:
     def test_create_span_retriever(self):
         """Test that retrievers create 'retriever' span type."""
         mock_client = Mock()
-        mock_client.start_as_current_span = Mock(return_value=MockContextManager())
         mock_client.start_as_current_observation = Mock(return_value=MockContextManager())
 
         handler = DefaultSpanHandler()
@@ -402,8 +430,9 @@ class TestDefaultSpanHandler:
             operation_name="haystack.component.run",
             component_type="InMemoryBM25Retriever",
             tags={},
-            parent_span=LangfuseSpan(mock_client.start_as_current_span()),
+            parent_span=LangfuseSpan(mock_client.start_as_current_observation()),
         )
+        mock_client.start_as_current_observation.reset_mock()
 
         span = handler.create_span(context)
         assert isinstance(span, LangfuseSpan)
@@ -414,7 +443,6 @@ class TestDefaultSpanHandler:
     def test_create_span_embedder(self):
         """Test that embedders create 'embedding' span type."""
         mock_client = Mock()
-        mock_client.start_as_current_span = Mock(return_value=MockContextManager())
         mock_client.start_as_current_observation = Mock(return_value=MockContextManager())
 
         handler = DefaultSpanHandler()
@@ -425,8 +453,9 @@ class TestDefaultSpanHandler:
             operation_name="haystack.component.run",
             component_type="SentenceTransformersDocumentEmbedder",
             tags={},
-            parent_span=LangfuseSpan(mock_client.start_as_current_span()),
+            parent_span=LangfuseSpan(mock_client.start_as_current_observation()),
         )
+        mock_client.start_as_current_observation.reset_mock()
 
         span = handler.create_span(context)
         assert isinstance(span, LangfuseSpan)
@@ -435,9 +464,8 @@ class TestDefaultSpanHandler:
         )
 
     def test_create_span_non_component(self):
-        """Test that non-matching components create regular spans."""
+        """Test that non-matching components create default span type."""
         mock_client = Mock()
-        mock_client.start_as_current_span = Mock(return_value=MockContextManager())
         mock_client.start_as_current_observation = Mock(return_value=MockContextManager())
 
         handler = DefaultSpanHandler()
@@ -448,15 +476,14 @@ class TestDefaultSpanHandler:
             operation_name="haystack.component.run",
             component_type="DocumentJoiner",
             tags={},
-            parent_span=LangfuseSpan(mock_client.start_as_current_span()),
+            parent_span=LangfuseSpan(mock_client.start_as_current_observation()),
         )
+        mock_client.start_as_current_observation.reset_mock()
 
         span = handler.create_span(context)
         assert isinstance(span, LangfuseSpan)
-        # Non-matching components should use start_as_current_span, not start_as_current_observation
-        mock_client.start_as_current_observation.assert_not_called()
-        # Verify start_as_current_span was called for the actual span creation (not just parent)
-        assert mock_client.start_as_current_span.call_count == 2  # Once for parent, once for the span
+        # Non-matching components use start_as_current_observation without explicit as_type
+        mock_client.start_as_current_observation.assert_called_once_with(name="DocumentJoiner")
 
     def test_handle_embedder_with_openai_format(self):
         """Test that embedder usage is extracted in OpenAI format."""
@@ -600,7 +627,6 @@ class TestLangfuseTracer:
             mock_span_instance._context_manager = mock_context_manager
 
             mock_tracer = Mock()
-            mock_tracer.start_as_current_span.return_value = mock_context_manager
             mock_tracer.start_as_current_observation.return_value = mock_context_manager
 
             tracer = LangfuseTracer(tracer=mock_tracer, name="Haystack", public=False)
@@ -616,15 +642,42 @@ class TestLangfuseTracer:
             # Check that the span is cleaned up after tracing
             assert tracer.current_span() is None, "There should be no active span after tracing completes"
 
-    # check that update method is called on the span instance with the provided key value pairs
-    def test_update_span_with_pipeline_input_output_data(self):
-        with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client"):
-            tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)
-            with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.input_data": "hello"}) as span:
-                assert span.raw_span()._data["metadata"] == {"haystack.pipeline.input_data": "hello"}
+    def test_pipeline_input_output_written_to_root_observation(self):
+        tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)
+        with tracer.trace(
+            operation_name="operation_name",
+            tags={
+                "haystack.pipeline.input_data": "hello",
+                "haystack.pipeline.output_data": "bye",
+            },
+        ) as span:
+            pass
+
+        # MockSpan._update_data mirrors kwargs into _data, so after the context exits
+        # we can verify update(input=..., output=...) was actually called.
+        assert span.raw_span()._data["input"] == "hello"
+        assert span.raw_span()._data["output"] == "bye"
 
-            with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.output_data": "bye"}) as span:
-                assert span.raw_span()._data["metadata"] == {"haystack.pipeline.output_data": "bye"}
+    def test_propagate_attributes_called_with_tracing_ctx_vars(self):
+        token = tracing_context_var.set(
+            {"user_id": "user123", "session_id": "sess456", "version": "v1", "tags": ["tag1"]}
+        )
+        try:
+            with patch("haystack_integrations.tracing.langfuse.tracer.propagate_attributes") as mock_propagate:
+                mock_propagate.return_value.__enter__ = Mock(return_value=None)
+                mock_propagate.return_value.__exit__ = Mock(return_value=False)
+                tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="MyPipeline", public=False)
+                with tracer.trace(operation_name="haystack.pipeline.run"):
+                    pass
+                mock_propagate.assert_called_once_with(
+                    trace_name="MyPipeline",
+                    user_id="user123",
+                    session_id="sess456",
+                    version="v1",
+                    tags=["tag1"],
+                )
+        finally:
+            tracing_context_var.reset(token)
 
     def test_trace_generation(self):
         with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client"):