langfuse-haystack 4.0.1__tar.gz → 5.0.0__tar.gz

{langfuse_haystack-4.0.1 → langfuse_haystack-5.0.0}/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [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)* Apply trace_id from tracing context to Langfuse traces (#2781)
+
+
 ## [integrations/langfuse-v4.0.0] - 2026-01-12
 
 ### 🧹 Chores

{langfuse_haystack-4.0.1 → langfuse_haystack-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfuse-haystack
-Version: 4.0.1
+Version: 5.0.0
 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.0.1 → langfuse_haystack-5.0.0}/example/basic_rag.py

@@ -62,5 +62,5 @@ if __name__ == "__main__":
     question = "What does Rhodes Statue look like?"
     response = pipeline.run({"text_embedder": {"text": question}, "prompt_builder": {"question": question}})
 
-    print(response["llm"]["replies"][0])  # noqa: T201
-    print(response["tracer"]["trace_url"])  # noqa: T201
+    print(response["llm"]["replies"][0])
+    print(response["tracer"]["trace_url"])

{langfuse_haystack-4.0.1 → langfuse_haystack-5.0.0}/example/chat.py

@@ -59,5 +59,5 @@ if __name__ == "__main__":
             },
         }
     )
-    print(response["llm"]["replies"][0])  # noqa: T201
-    print(response["tracer"]["trace_url"])  # noqa: T201
+    print(response["llm"]["replies"][0])
+    print(response["tracer"]["trace_url"])

langfuse_haystack-5.0.0/pydoc/config_docusaurus.yml

@@ -0,0 +1,14 @@
+loaders:
+  - modules:
+      - haystack_integrations.components.connectors.langfuse.langfuse_connector
+      - haystack_integrations.tracing.langfuse.tracer
+    search_path: [../src]
+processors:
+  - type: filter
+    documented_only: true
+    skip_empty_modules: true
+renderer:
+  description: Langfuse integration for Haystack
+  id: integrations-langfuse
+  filename: langfuse.md
+  title: langfuse

{langfuse_haystack-4.0.1 → langfuse_haystack-5.0.0}/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"
@@ -45,7 +45,7 @@ installer = "uv"
 dependencies = ["haystack-pydoc-tools", "ruff"]
 
 [tool.hatch.envs.default.scripts]
-docs = ["pydoc-markdown pydoc/config_docusaurus.yml"]
+docs = ["haystack-pydoc pydoc/config_docusaurus.yml"]
 fmt = "ruff check --fix {args}; ruff format {args}"
 fmt-check = "ruff check {args} && ruff format --check {args}"
 
@@ -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}"
 
@@ -76,8 +77,6 @@ non_interactive = true
 check_untyped_defs = true
 disallow_incomplete_defs = true
 
-[tool.hatch.metadata]
-allow-direct-references = true
 
 
 [tool.ruff]
@@ -86,9 +85,17 @@ line-length = 120
 [tool.ruff.lint]
 select = [
   "A",
+  "ANN",
   "ARG",
   "B",
   "C",
+  "D102",   # Missing docstring in public method
+  "D103",   # Missing docstring in public function
+  "D205",   # 1 blank line required between summary line and description
+  "D209",   # Closing triple quotes go to new line
+  "D213",   # summary lines must be positioned on the second physical line of the docstring
+  "D417",   # Missing argument descriptions in the docstring
+  "D419",   # Docstring is empty
   "DTZ",
   "E",
   "EM",
@@ -125,6 +132,8 @@ ignore = [
   "PLR0915",
   # Asserts
   "S101",
+  # Allow `Any` - used legitimately for dynamic types and SDK boundaries
+  "ANN401",
 ]
 
 [tool.ruff.lint.isort]
@@ -135,14 +144,16 @@ ban-relative-imports = "parents"
 
 [tool.ruff.lint.per-file-ignores]
 # Tests can use magic values, assertions, and relative imports
-"tests/**/*" = ["PLR2004", "S101", "TID252"]
+"tests/**/*" = ["D", "PLR2004", "S101", "TID252", "ANN"]
 # Examples can print their output
-"examples/**" = ["T201"]
+"examples/**" = ["T201", "ANN", "D"]
+"example/**" = ["T201", "ANN", "D"]
 "tests/**" = ["T201"]
 
 [tool.coverage.run]
 source = ["haystack_integrations"]
 branch = true
+relative_files = true
 parallel = false
 
 
@@ -150,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.0.1 → langfuse_haystack-5.0.0}/src/haystack_integrations/components/connectors/langfuse/langfuse_connector.py

@@ -19,6 +19,7 @@ logger = logging.getLogger(__name__)
 class LangfuseConnector:
     """
     LangfuseConnector connects Haystack LLM framework with [Langfuse](https://langfuse.com) in order to enable the
+
     tracing of operations and data flow within various components of a pipeline.
 
     To use LangfuseConnector, add it to your pipeline without connecting it to any other components.

{langfuse_haystack-4.0.1 → langfuse_haystack-5.0.0}/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__()
@@ -91,7 +91,10 @@ class LangfuseSpan(Span):
         if key.endswith(".input"):
             if "messages" in value:
                 messages = [m.to_openai_dict_format(require_tool_call_ids=False) for m in value["messages"]]
-                self._span.update(input=messages)
+                if isinstance(gen_kwargs := value.get("generation_kwargs"), dict):
+                    self._span.update(input={"messages": messages, "generation_kwargs": gen_kwargs})
+                else:
+                    self._span.update(input=messages)
             else:
                 coerced_value = tracing_utils.coerce_tag_value(value)
                 self._span.update(input=coerced_value)
@@ -125,6 +128,7 @@ class LangfuseSpan(Span):
         return self._data
 
     def get_correlation_data_for_logs(self) -> dict[str, Any]:
+        """Return correlation data for log enrichment."""
         return {}
 
 
@@ -234,9 +238,11 @@ class SpanHandler(ABC):
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> "SpanHandler":
+        """Deserialize a SpanHandler from a dictionary."""
         return default_from_dict(cls, data)
 
     def to_dict(self) -> dict[str, Any]:
+        """Serialize this SpanHandler to a dictionary."""
         return default_to_dict(self)
 
 
@@ -273,6 +279,7 @@ class DefaultSpanHandler(SpanHandler):
     """DefaultSpanHandler provides the default Langfuse tracing behavior for Haystack."""
 
     def create_span(self, context: SpanContext) -> LangfuseSpan:
+        """Create a Langfuse span based on the given context."""
         if self.tracer is None:
             message = (
                 "Tracer is not initialized. "
@@ -290,33 +297,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
 
@@ -340,15 +331,16 @@ 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."""
         # If the span is at the pipeline level, we add input and output keys to the span
         at_pipeline_level = span.get_data().get(_PIPELINE_INPUT_KEY) is not None
         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] = []
@@ -456,9 +448,11 @@ class LangfuseTracer(Tracer):
     def trace(
         self, operation_name: str, tags: dict[str, Any] | None = None, parent_span: Span | None = None
     ) -> Iterator[Span]:
+        """Create and manage a tracing span as a context manager."""
         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(
@@ -473,76 +467,94 @@ 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."""
         self._tracer.flush()
 
     def current_span(self) -> Span | None:
@@ -558,6 +570,7 @@ class LangfuseTracer(Tracer):
     def get_trace_url(self) -> str:
         """
         Return the URL to the tracing data.
+
         :return: The URL to the tracing data.
         """
         return self._tracer.get_trace_url() or ""
@@ -565,6 +578,7 @@ class LangfuseTracer(Tracer):
     def get_trace_id(self) -> str:
         """
         Return the trace ID.
+
         :return: The trace ID.
         """
         return self._tracer.get_current_trace_id() or ""

{langfuse_haystack-4.0.1 → langfuse_haystack-5.0.0}/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,44 +128,57 @@ 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()
-
-        # test message input
         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 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"]}
+        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 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"]}
 
 
 class TestSpanContext:
@@ -226,7 +233,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()
@@ -261,6 +267,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
@@ -332,7 +356,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()
@@ -343,8 +366,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)
@@ -355,7 +379,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()
@@ -366,8 +389,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)
@@ -378,7 +402,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()
@@ -389,8 +412,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)
@@ -401,7 +425,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()
@@ -412,8 +435,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)
@@ -422,9 +446,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()
@@ -435,15 +458,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."""
@@ -568,7 +590,7 @@ class TestLangfuseTracer:
         assert tracer._public
 
     def test_create_new_span(self):
-        mock_raw_span = MagicMock()
+        mock_raw_span = Mock()
         mock_raw_span.operation_name = "operation_name"
         mock_raw_span.metadata = {"tag1": "value1", "tag2": "value2"}
 
@@ -586,8 +608,7 @@ class TestLangfuseTracer:
             mock_span_instance.get_data.return_value = {}
             mock_span_instance._context_manager = mock_context_manager
 
-            mock_tracer = MagicMock()
-            mock_tracer.start_as_current_span.return_value = mock_context_manager
+            mock_tracer = Mock()
             mock_tracer.start_as_current_observation.return_value = mock_context_manager
 
             tracer = LangfuseTracer(tracer=mock_tracer, name="Haystack", public=False)
@@ -603,15 +624,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
 
-            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"}
+        # 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"
+
+    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"):

langfuse_haystack-4.0.1/pydoc/config_docusaurus.yml

@@ -1,29 +0,0 @@
-loaders:
-- ignore_when_discovered:
-  - __init__
-  modules:
-  - haystack_integrations.components.connectors.langfuse.langfuse_connector
-  - haystack_integrations.tracing.langfuse.tracer
-  search_path:
-  - ../src
-  type: haystack_pydoc_tools.loaders.CustomPythonLoader
-processors:
-- do_not_filter_modules: false
-  documented_only: true
-  expression: null
-  skip_empty_modules: true
-  type: filter
-- type: smart
-- type: crossref
-renderer:
-  description: Langfuse integration for Haystack
-  id: integrations-langfuse
-  markdown:
-    add_member_class_prefix: false
-    add_method_class_prefix: true
-    classdef_code_block: false
-    descriptive_class_title: false
-    descriptive_module_title: true
-    filename: langfuse.md
-  title: langfuse
-  type: haystack_pydoc_tools.renderers.DocusaurusRenderer