langfuse-haystack 2.3.0__tar.gz → 3.1.0__tar.gz

{langfuse_haystack-2.3.0 → langfuse_haystack-3.1.0}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [integrations/langfuse-v3.0.0] - 2025-09-19
+
+### 🌀 Miscellaneous
+
+- Migrate langfuse to v3 (#2247)
+
+## [integrations/langfuse-v2.3.0] - 2025-08-25
+
+### 🐛 Bug Fixes
+
+- Avoid mixed Langfuse traces in async envs (#2207)
+
+### 🧪 Testing
+
+- Make tests successfully run from forks (#2203)
+
+### 🧹 Chores
+
+- Standardize readmes - part 2 (#2205)
+
+
 ## [integrations/langfuse-v2.2.1] - 2025-08-07
 
 ### 🚀 Features

{langfuse_haystack-2.3.0 → langfuse_haystack-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfuse-haystack
-Version: 2.3.0
+Version: 3.1.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,8 +18,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9
-Requires-Dist: haystack-ai>=2.15.1
-Requires-Dist: langfuse<3.0.0,>=2.9.0
+Requires-Dist: haystack-ai>=2.17.1
+Requires-Dist: langfuse<4.0.0,>=3.3.0
 Description-Content-Type: text/markdown
 
 # langfuse-haystack

{langfuse_haystack-2.3.0 → langfuse_haystack-3.1.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])
-    print(response["tracer"]["trace_url"])
+    print(response["llm"]["replies"][0])  # noqa: T201
+    print(response["tracer"]["trace_url"])  # noqa: T201

{langfuse_haystack-2.3.0 → langfuse_haystack-3.1.0}/example/chat.py

@@ -36,7 +36,6 @@ generators = {
 selected_chat_generator = generators[selected_chat_generator]()
 
 if __name__ == "__main__":
-
     pipe = Pipeline()
     pipe.add_component("tracer", LangfuseConnector("Chat example"))
     pipe.add_component("prompt_builder", ChatPromptBuilder())
@@ -60,5 +59,5 @@ if __name__ == "__main__":
             },
         }
     )
-    print(response["llm"]["replies"][0])
-    print(response["tracer"]["trace_url"])
+    print(response["llm"]["replies"][0])  # noqa: T201
+    print(response["tracer"]["trace_url"])  # noqa: T201

langfuse_haystack-3.1.0/pydoc/config_docusaurus.yml

@@ -0,0 +1,29 @@
+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

{langfuse_haystack-2.3.0 → langfuse_haystack-3.1.0}/pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.15.1", "langfuse>=2.9.0, <3.0.0"]
+dependencies = ["haystack-ai>=2.17.1", "langfuse>=3.3.0, <4.0.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse#readme"
@@ -69,22 +69,13 @@ integration = 'pytest -m "integration" {args:tests}'
 all = 'pytest {args:tests}'
 cov-retry = 'all --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x'
 
-types = "mypy --install-types --non-interactive --explicit-package-bases {args:src/ tests}"
+types = "mypy -p haystack_integrations.components.connectors.langfuse -p haystack_integrations.tracing.langfuse {args}"
 
-# TODO: remove lint environment once this integration is properly typed
-# test environment should be used instead
-# https://github.com/deepset-ai/haystack-core-integrations/issues/1771
-[tool.hatch.envs.lint]
-installer = "uv"
-detached = true
-dependencies = [
-    "pip",
-    "mypy>=1.0.0",
-    "ruff>=0.0.243",
-]
-
-[tool.hatch.envs.lint.scripts]
-typing = "mypy --install-types --non-interactive --explicit-package-bases {args:src/ tests}"
+[tool.mypy]
+install_types = true
+non_interactive = true
+check_untyped_defs = true
+disallow_incomplete_defs = true
 
 [tool.hatch.metadata]
 allow-direct-references = true
@@ -93,7 +84,6 @@ allow-direct-references = true
 [tool.ruff]
 target-version = "py38"
 line-length = 120
-exclude = ["example", "tests"]
 
 [tool.ruff.lint]
 select = [
@@ -167,17 +157,6 @@ omit = ["*/tests/*", "*/__init__.py"]
 show_missing = true
 exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
 
-[[tool.mypy.overrides]]
-module = [
-  "langfuse.*",
-  "haystack.*",
-  "haystack_integrations.*",
-  "pytest.*",
-  "numpy.*",
-  "httpx.*",
-]
-ignore_missing_imports = true
-
 [tool.pytest.ini_options]
 addopts = "--strict-markers"
 markers = ["integration: integration tests"]

{langfuse_haystack-2.3.0 → langfuse_haystack-3.1.0}/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -6,24 +6,21 @@ import contextlib
 import os
 from abc import ABC, abstractmethod
 from collections import Counter
+from contextlib import AbstractContextManager
 from contextvars import ContextVar
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, Iterator, List, Optional, Union
+from typing import Any, Dict, Iterator, List, Optional
 
 from haystack import default_from_dict, default_to_dict, logging
 from haystack.dataclasses import ChatMessage
 from haystack.tracing import Span, Tracer
 from haystack.tracing import tracer as proxy_tracer
 from haystack.tracing import utils as tracing_utils
-from typing_extensions import TypeAlias
 
 import langfuse
-from langfuse.client import StatefulGenerationClient, StatefulSpanClient, StatefulTraceClient
-
-# Type alias for Langfuse stateful clients
-LangfuseStatefulClient: TypeAlias = Union[StatefulTraceClient, StatefulSpanClient, StatefulGenerationClient]
-
+from langfuse import LangfuseSpan as LangfuseClientSpan
+from langfuse.types import TraceMetadata
 
 logger = logging.getLogger(__name__)
 
@@ -75,15 +72,17 @@ class LangfuseSpan(Span):
     Internal class representing a bridge between the Haystack span tracing API and Langfuse.
     """
 
-    def __init__(self, span: LangfuseStatefulClient) -> None:
+    def __init__(self, context_manager: AbstractContextManager) -> None:
         """
         Initialize a LangfuseSpan instance.
 
-        :param span: The span instance managed by Langfuse.
+        :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 = span
-        # locally cache tags
+        self._span = context_manager.__enter__()
         self._data: Dict[str, Any] = {}
+        self._context_manager = context_manager
 
     def set_tag(self, key: str, value: Any) -> None:
         """
@@ -125,7 +124,7 @@ class LangfuseSpan(Span):
 
         self._data[key] = value
 
-    def raw_span(self) -> LangfuseStatefulClient:
+    def raw_span(self) -> LangfuseClientSpan:
         """
         Return the underlying span instance.
 
@@ -273,21 +272,36 @@ class DefaultSpanHandler(SpanHandler):
         tracing_ctx = tracing_context_var.get({})
         if not context.parent_span:
             # Create a new trace when there's no parent span
-            return LangfuseSpan(
-                self.tracer.trace(
-                    name=context.trace_name,
-                    public=context.public,
-                    id=tracing_ctx.get("trace_id"),
-                    user_id=tracing_ctx.get("user_id"),
-                    session_id=tracing_ctx.get("session_id"),
-                    tags=tracing_ctx.get("tags"),
-                    version=tracing_ctx.get("version"),
-                )
+            span_context_manager = self.tracer.start_as_current_span(
+                name=context.trace_name,
+                version=tracing_ctx.get("version"),
             )
+
+            # 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)
+
+            return span
         elif context.component_type in _ALL_SUPPORTED_GENERATORS:
-            return LangfuseSpan(context.parent_span.raw_span().generation(name=context.name))
+            return LangfuseSpan(self.tracer.start_as_current_observation(name=context.name, as_type="generation"))
         else:
-            return LangfuseSpan(context.parent_span.raw_span().span(name=context.name))
+            return LangfuseSpan(self.tracer.start_as_current_span(name=context.name))
 
     def handle(self, span: LangfuseSpan, component_type: Optional[str]) -> None:
         # If the span is at the pipeline level, we add input and output keys to the span
@@ -295,8 +309,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(input=coerced_input, output=coerced_output)
-
+            span.raw_span().update_trace(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] = []
@@ -415,7 +428,11 @@ class LangfuseTracer(Tracer):
 
                 # End span (may fail if span data is corrupted)
                 raw_span = span.raw_span()
-                if isinstance(raw_span, (StatefulSpanClient, StatefulGenerationClient)):
+                # In v3, we need to properly exit context managers
+                if span._context_manager is not None:
+                    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
@@ -449,11 +466,11 @@ class LangfuseTracer(Tracer):
         Return the URL to the tracing data.
         :return: The URL to the tracing data.
         """
-        return self._tracer.get_trace_url()
+        return self._tracer.get_trace_url() or ""
 
     def get_trace_id(self) -> str:
         """
         Return the trace ID.
         :return: The trace ID.
         """
-        return self._tracer.get_trace_id()
+        return self._tracer.get_current_trace_id() or ""

{langfuse_haystack-2.3.0 → langfuse_haystack-3.1.0}/tests/test_tracer.py

@@ -6,12 +6,10 @@ import asyncio
 import datetime
 import logging
 import sys
-import json
 from typing import Optional
 from unittest.mock import MagicMock, Mock, patch
 
 import pytest
-from haystack import Pipeline, component
 from haystack.dataclasses import ChatMessage, ToolCall
 
 from haystack_integrations.tracing.langfuse.tracer import (
@@ -21,15 +19,41 @@ from haystack_integrations.tracing.langfuse.tracer import (
     LangfuseTracer,
     SpanContext,
 )
-from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+
+
+# 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"""
+
+    def __init__(self, name="mock_span"):
+        self._span = MockSpan(name)
+
+    def __enter__(self):
+        return self._span
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
 
 
 class MockSpan:
     def __init__(self, name="mock_span"):
         self._data = {}
-        self._span = self
         self.operation_name = name
         self._name = name
+        # Make update a Mock so we can assert on it, but also make it actually work
+        self.update = Mock(side_effect=self._update_data)
+
+    def _update_data(self, **kwargs):
+        """Helper method to actually update _data when update is called"""
+        self._data.update(kwargs)
 
     def raw_span(self):
         return self
@@ -38,7 +62,8 @@ class MockSpan:
         # Return a new mock span for child spans
         return MockSpan(name=name or "child_span")
 
-    def update(self, **kwargs):
+    def update_trace(self, **kwargs):
+        # v3 API method for updating trace-level data
         self._data.update(kwargs)
 
     def generation(self, name=None):
@@ -50,7 +75,7 @@ class MockSpan:
 
 
 class MockTracer:
-    def trace(self, name, **kwargs):
+    def trace(self, name, **kwargs):  # noqa: ARG002
         # Return a unique mock span for each trace call
         return MockSpan(name=name)
 
@@ -58,6 +83,28 @@ class MockTracer:
         pass
 
 
+class MockLangfuseClient:
+    """Mock Langfuse client that has all the required methods"""
+
+    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
+
+    def get_current_trace_id(self):
+        return "mock_trace_id_123"
+
+    def get_current_observation_id(self):
+        return "mock_observation_id_123"
+
+    def flush(self):
+        pass
+
+
 class CustomSpanHandler(DefaultSpanHandler):
     def handle(self, span: LangfuseSpan, component_type: Optional[str]) -> None:
         if component_type == "OpenAIChatGenerator":
@@ -70,58 +117,60 @@ class CustomSpanHandler(DefaultSpanHandler):
 class TestLangfuseSpan:
     #  LangfuseSpan can be initialized with a span object
     def test_initialized_with_span_object(self):
-        mock_span = Mock()
-        span = LangfuseSpan(mock_span)
-        assert span.raw_span() == mock_span
+        mock_context_manager = MockContextManager()
+        span = LangfuseSpan(mock_context_manager)
+        assert span.raw_span() == mock_context_manager._span
 
     #  set_tag method can update metadata of the span object
     def test_set_tag_updates_metadata(self):
-        mock_span = Mock()
-        span = LangfuseSpan(mock_span)
+        mock_context_manager = MockContextManager()
+        span = LangfuseSpan(mock_context_manager)
 
         span.set_tag("key", "value")
-        mock_span.update.assert_called_once_with(metadata={"key": "value"})
+        mock_context_manager._span.update.assert_called_once_with(metadata={"key": "value"})
         assert span._data["key"] == "value"
 
     #  set_content_tag method can update input and output of the span object
     def test_set_content_tag_updates_input_and_output(self):
-        mock_span = Mock()
+        mock_context_manager = MockContextManager()
 
-        span = LangfuseSpan(mock_span)
-        span.set_content_tag("input_key", "input_value")
-        assert span._data["input_key"] == "input_value"
+        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_span.reset_mock()
-        span.set_content_tag("output_key", "output_value")
-        assert span._data["output_key"] == "output_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")
 
     # 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_span = Mock()
+        mock_context_manager = MockContextManager()
 
         # test message input
-        span = LangfuseSpan(mock_span)
+        span = LangfuseSpan(mock_context_manager)
         span.set_content_tag("key.input", {"messages": [ChatMessage.from_user("message")]})
-        assert mock_span.update.call_count == 1
+        assert mock_context_manager._span.update.call_count == 1
         # check we converted ChatMessage to OpenAI format
-        assert mock_span.update.call_args_list[0][1] == {"input": [{"role": "user", "content": "message"}]}
-        assert span._data["key.input"] == {"messages": [ChatMessage.from_user("message")]}
-
+        assert mock_context_manager._span.update.call_args_list[0][1] == {
+            "input": [{"role": "user", "content": "message"}]
+        }
         # test replies ChatMessage list
-        mock_span.reset_mock()
+        mock_context_manager._span.update.reset_mock()
         span.set_content_tag("key.output", {"replies": [ChatMessage.from_system("reply")]})
-        assert mock_span.update.call_count == 1
+        assert mock_context_manager._span.update.call_count == 1
         # check we converted ChatMessage to OpenAI format
-        assert mock_span.update.call_args_list[0][1] == {"output": [{"role": "system", "content": "reply"}]}
-        assert span._data["key.output"] == {"replies": [ChatMessage.from_system("reply")]}
+        assert mock_context_manager._span.update.call_args_list[0][1] == {
+            "output": [{"role": "system", "content": "reply"}]
+        }
 
         # test replies string list
-        mock_span.reset_mock()
+        mock_context_manager._span.update.reset_mock()
         span.set_content_tag("key.output", {"replies": ["reply1", "reply2"]})
-        assert mock_span.update.call_count == 1
+        assert mock_context_manager._span.update.call_count == 1
         # check we handle properly string list replies
-        assert mock_span.update.call_args_list[0][1] == {"output": ["reply1", "reply2"]}
-        assert span._data["key.output"] == {"replies": ["reply1", "reply2"]}
+        assert mock_context_manager._span.update.call_args_list[0][1] == {"output": ["reply1", "reply2"]}
 
 
 class TestSpanContext:
@@ -178,7 +227,9 @@ class TestDefaultSpanHandler:
         assert mock_span.update.call_args_list[0][1] == {
             "usage": None,
             "model": "test_model",
-            "completion_start_time": datetime.datetime(2021, 7, 27, 16, 2, 8, 12345),
+            "completion_start_time": datetime.datetime(  # noqa: DTZ001
+                2021, 7, 27, 16, 2, 8, 12345
+            ),
         }
 
     def test_handle_bad_completion_start_time(self, caplog):
@@ -250,15 +301,14 @@ class TestLangfuseTracer:
         mock_raw_span.operation_name = "operation_name"
         mock_raw_span.metadata = {"tag1": "value1", "tag2": "value2"}
 
-        with patch("haystack_integrations.tracing.langfuse.tracer.LangfuseSpan") as MockLangfuseSpan:
-            mock_span_instance = MockLangfuseSpan.return_value
+        with patch("haystack_integrations.tracing.langfuse.tracer.LangfuseSpan") as mock_langfuse_span:
+            mock_span_instance = mock_langfuse_span.return_value
             mock_span_instance.raw_span.return_value = mock_raw_span
 
-            mock_context_manager = MagicMock()
-            mock_context_manager.__enter__.return_value = mock_span_instance
-
+            mock_context_manager = MockContextManager()
+            mock_context_manager._span = mock_raw_span
             mock_tracer = MagicMock()
-            mock_tracer.trace.return_value = mock_context_manager
+            mock_tracer.start_as_current_span.return_value = mock_context_manager
 
             tracer = LangfuseTracer(tracer=mock_tracer, name="Haystack", public=False)
 
@@ -275,30 +325,32 @@ class TestLangfuseTracer:
 
     # 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):
-        tracer = LangfuseTracer(tracer=MockTracer(), 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"}
+        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"}
 
-        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"}
+            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_trace_generation(self):
-        tracer = LangfuseTracer(tracer=MockTracer(), name="Haystack", public=False)
-        tags = {
-            "haystack.component.type": "OpenAIChatGenerator",
-            "haystack.component.output": {
-                "replies": [
-                    ChatMessage.from_assistant(
-                        "", meta={"completion_start_time": "2021-07-27T16:02:08.012345", "model": "test_model"}
-                    )
-                ]
-            },
-        }
-        with tracer.trace(operation_name="operation_name", tags=tags) as span:
-            ...
-        assert span.raw_span()._data["usage"] is None
-        assert span.raw_span()._data["model"] == "test_model"
-        assert span.raw_span()._data["completion_start_time"] == datetime.datetime(2021, 7, 27, 16, 2, 8, 12345)
+        with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client"):
+            tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)
+            tags = {
+                "haystack.component.type": "OpenAIChatGenerator",
+                "haystack.component.output": {
+                    "replies": [
+                        ChatMessage.from_assistant(
+                            "", meta={"completion_start_time": "2021-07-27T16:02:08.012345", "model": "test_model"}
+                        )
+                    ]
+                },
+            }
+            with tracer.trace(operation_name="operation_name", tags=tags) as span:
+                ...
+            assert span.raw_span()._data["usage"] is None
+            assert span.raw_span()._data["model"] == "test_model"
+            assert span.raw_span()._data["completion_start_time"] == datetime.datetime(2021, 7, 27, 16, 2, 8, 12345)  # noqa: DTZ001
 
     def test_handle_tool_invoker(self):
         """
@@ -342,7 +394,7 @@ class TestLangfuseTracer:
         updated_name = name_update_call[1]["name"]
 
         # verify the format of the updated span name to be: `original_component_name - [list_of_tool_names]`
-        assert updated_name != "tool_invoker", f"Expected 'tool_invoker` to be upddated with tool names"
+        assert updated_name != "tool_invoker", "Expected 'tool_invoker` to be upddated with tool names"
         assert " - " in updated_name, f"Expected ' - ' in {updated_name}"
         assert "[" in updated_name, f"Expected '[' in {updated_name}"
         assert "]" in updated_name, f"Expected ']' in {updated_name}"
@@ -351,47 +403,51 @@ class TestLangfuseTracer:
         assert "weather_tool" in updated_name, f"Expected 'weather_tool' in {updated_name}"
 
     def test_trace_generation_invalid_start_time(self):
-        tracer = LangfuseTracer(tracer=MockTracer(), name="Haystack", public=False)
-        tags = {
-            "haystack.component.type": "OpenAIChatGenerator",
-            "haystack.component.output": {
-                "replies": [
-                    ChatMessage.from_assistant("", meta={"completion_start_time": "foobar", "model": "test_model"}),
-                ]
-            },
-        }
-        with tracer.trace(operation_name="operation_name", tags=tags) as span:
-            ...
-        assert span.raw_span()._data["usage"] is None
-        assert span.raw_span()._data["model"] == "test_model"
-        assert span.raw_span()._data["completion_start_time"] is None
+        with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client"):
+            tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)
+            tags = {
+                "haystack.component.type": "OpenAIChatGenerator",
+                "haystack.component.output": {
+                    "replies": [
+                        ChatMessage.from_assistant("", meta={"completion_start_time": "foobar", "model": "test_model"}),
+                    ]
+                },
+            }
+            with tracer.trace(operation_name="operation_name", tags=tags) as span:
+                ...
+            assert span.raw_span()._data["usage"] is None
+            assert span.raw_span()._data["model"] == "test_model"
+            assert span.raw_span()._data["completion_start_time"] is None
 
     def test_update_span_gets_flushed_by_default(self):
-        tracer_mock = Mock()
+        tracer_mock = MockLangfuseClient()
+        tracer_mock.flush = Mock()  # Make flush a mock for assertions
 
         tracer = LangfuseTracer(tracer=tracer_mock, name="Haystack", public=False)
-        with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.input_data": "hello"}) as span:
+        with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.input_data": "hello"}):
             pass
 
         tracer_mock.flush.assert_called_once()
 
     def test_update_span_flush_disable(self, monkeypatch):
         monkeypatch.setenv("HAYSTACK_LANGFUSE_ENFORCE_FLUSH", "false")
-        tracer_mock = Mock()
+        tracer_mock = MockLangfuseClient()
+        tracer_mock.flush = Mock()  # Make flush a mock for assertions
 
-        from haystack_integrations.tracing.langfuse.tracer import LangfuseTracer
+        # Re-import LangfuseTracer to ensure it picks up the new environment variable
+        from haystack_integrations.tracing.langfuse.tracer import LangfuseTracer  # noqa: PLC0415
 
         tracer = LangfuseTracer(tracer=tracer_mock, name="Haystack", public=False)
-        with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.input_data": "hello"}) as span:
+        with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.input_data": "hello"}):
             pass
 
         tracer_mock.flush.assert_not_called()
 
     def test_context_is_empty_after_tracing(self):
-        tracer_mock = Mock()
+        tracer_mock = MockLangfuseClient()
 
         tracer = LangfuseTracer(tracer=tracer_mock, name="Haystack", public=False)
-        with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.input_data": "hello"}) as span:
+        with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.input_data": "hello"}):
             pass
 
         # Check behavioral state instead of internal _context list
@@ -406,11 +462,11 @@ class TestLangfuseTracer:
         # Re-import LangfuseTracer and instantiate it with tracing disabled
         with caplog.at_level(logging.WARNING):
             monkeypatch.setenv("HAYSTACK_CONTENT_TRACING_ENABLED", "false")
-            from haystack_integrations.tracing.langfuse import LangfuseTracer
+            from haystack_integrations.tracing.langfuse import LangfuseTracer  # noqa: PLC0415
 
-            LangfuseTracer(tracer=MockTracer(), name="Haystack", public=False)
+            LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)
             assert "tracing is disabled" in caplog.text
-            
+
     def test_async_concurrency_span_isolation(self):
         """
         Test that concurrent async traces maintain isolated span contexts.
@@ -418,7 +474,7 @@ class TestLangfuseTracer:
         This test verifies that the context-local span stack prevents cross-request
         span interleaving in concurrent environments like FastAPI servers.
         """
-        tracer = LangfuseTracer(tracer=MockTracer(), name="Haystack", public=False)
+        tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)
 
         # Track spans from each task for verification
         task1_spans = []
@@ -482,4 +538,3 @@ class TestLangfuseTracer:
         assert task2_spans[1][2] == task2_inner  # current_span during inner
         assert task2_spans[2][2] == task2_outer  # current_span after inner
         assert task2_spans[3][2] is None  # current_span after outer
-  

{langfuse_haystack-2.3.0 → langfuse_haystack-3.1.0}/tests/test_tracing.py

@@ -2,11 +2,11 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import json
 import os
 import time
 from typing import Any, Dict, List
 from urllib.parse import urlparse
-import json
 
 import pytest
 import requests
@@ -17,12 +17,23 @@ from haystack.dataclasses import ChatMessage
 from requests.auth import HTTPBasicAuth
 
 from haystack_integrations.components.connectors.langfuse import LangfuseConnector
-from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator
-from haystack_integrations.components.generators.cohere import CohereChatGenerator
+
+# We use the try/except block to prevent import errors when running unit tests with lowest direct dependencies,
+# where the subdependencies of LLM integrations might not be respected.
+try:
+    from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator
+except ImportError:
+    AnthropicChatGenerator = None
+try:
+    from haystack_integrations.components.generators.cohere import CohereChatGenerator
+except ImportError:
+    CohereChatGenerator = None
 
 # don't remove (or move) this env var setting from here, it's needed to turn tracing on
 os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
 
+os.environ.setdefault("LANGFUSE_HOST", "https://cloud.langfuse.com")
+
 
 def poll_langfuse(url: str):
     """Utility function to poll Langfuse API until the trace is ready"""
@@ -36,7 +47,7 @@ def poll_langfuse(url: str):
 
     res = None
     while attempts > 0:
-        res = requests.get(url, auth=auth)
+        res = requests.get(url, auth=auth, timeout=60.0)
         if res.status_code == 200:
             return res
 
@@ -71,7 +82,7 @@ def basic_pipeline(llm_class, expected_trace):
         (CohereChatGenerator, "COHERE_API_KEY", "Cohere"),
     ],
 )
-def test_tracing_integration(llm_class, env_var, expected_trace, basic_pipeline):
+def test_tracing_integration(env_var, expected_trace, basic_pipeline):
     if not all([os.environ.get("LANGFUSE_SECRET_KEY"), os.environ.get("LANGFUSE_PUBLIC_KEY"), os.environ.get(env_var)]):
         pytest.skip(f"Missing required environment variable: {env_var}")
 
@@ -92,7 +103,7 @@ def test_tracing_integration(llm_class, env_var, expected_trace, basic_pipeline)
 
     trace_url = response["tracer"]["trace_url"]
     uuid = os.path.basename(urlparse(trace_url).path)
-    url = f"https://cloud.langfuse.com/api/public/traces/{uuid}"
+    url = f"{os.environ['LANGFUSE_HOST']}/api/public/traces/{uuid}"
 
     res = poll_langfuse(url)
     assert res.status_code == 200, f"Failed to retrieve data from Langfuse API: {res.status_code}"
@@ -104,7 +115,8 @@ def test_tracing_integration(llm_class, env_var, expected_trace, basic_pipeline)
     assert isinstance(res_json["output"], dict)
     assert isinstance(res_json["metadata"], dict)
     assert isinstance(res_json["observations"], list)
-    assert res_json["observations"][0]["type"] == "GENERATION"
+    # at least one observation should be a generation
+    assert any(obs["type"] == "GENERATION" for obs in res_json["observations"])
 
 
 @pytest.mark.skipif(
@@ -119,7 +131,6 @@ def test_tracing_integration(llm_class, env_var, expected_trace, basic_pipeline)
 )
 @pytest.mark.integration
 def test_tracing_with_sub_pipelines():
-
     @component
     class SubGenerator:
         def __init__(self):
@@ -165,7 +176,7 @@ def test_tracing_with_sub_pipelines():
 
     trace_url = response["tracer"]["trace_url"]
     uuid = os.path.basename(urlparse(trace_url).path)
-    url = f"https://cloud.langfuse.com/api/public/traces/{uuid}"
+    url = f"{os.environ['LANGFUSE_HOST']}/api/public/traces/{uuid}"
 
     res = poll_langfuse(url)
     assert res.status_code == 200, f"Failed to retrieve data from Langfuse API: {res.status_code}"
@@ -173,23 +184,20 @@ def test_tracing_with_sub_pipelines():
     res_json = res.json()
     assert res_json["name"] == "Sub-pipeline example"
     assert isinstance(res_json["input"], dict)
-    assert "sub_pipeline" in res_json["input"]
-    assert "messages" in res_json["input"]["sub_pipeline"]
-    assert res_json["input"]["tracer"]["invocation_context"]["user_id"] == "user_42"
     assert isinstance(res_json["output"], dict)
     assert isinstance(res_json["metadata"], dict)
     assert isinstance(res_json["observations"], list)
 
     observations = res_json["observations"]
+    assert len(observations) == 8
 
     haystack_pipeline_run_observations = [obs for obs in observations if obs["name"] == "haystack.pipeline.run"]
     # There should be two observations for the haystack.pipeline.run span: one for each sub pipeline
     # Main pipeline is stored under the name "Sub-pipeline example"
     assert len(haystack_pipeline_run_observations) == 2
-    # Apparently the order of haystack_pipeline_run_observations isn't deterministic
-    component_names = [key for obs in haystack_pipeline_run_observations for key in obs["input"].keys()]
-    assert "prompt_builder" in component_names
-    assert "llm" in component_names
+    assert "prompt_builder" in str(haystack_pipeline_run_observations[0])
+    assert "llm" in str(haystack_pipeline_run_observations[1])
+
 
 @pytest.mark.skipif(
     not all(
@@ -243,7 +251,7 @@ def test_context_cleanup_after_nested_failures():
     # Test 1: First run will fail and should clean up context
     try:
         main_pipeline.run({"nested_component": {"input_data": "invalid json"}})
-    except Exception:
+    except Exception:  # noqa: S110
         pass  # Expected to fail
 
     # Critical assertion: context should be empty after failed operation
@@ -251,6 +259,6 @@ def test_context_cleanup_after_nested_failures():
 
     # Test 2: Second run should work normally with clean context
     main_pipeline.run({"nested_component": {"input_data": '{"key": "valid"}'}})
-    
+
     # Critical assertion: context should be empty after successful operation
-    assert len(tracer.tracer._context) == 0    
+    assert len(tracer.tracer._context) == 0