langfuse-haystack 3.0.0__tar.gz → 3.2.0__tar.gz

{langfuse_haystack-3.0.0 → langfuse_haystack-3.2.0}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [integrations/langfuse-v3.1.0] - 2025-10-24
+
+### 🐛 Bug Fixes
+
+- Langfuse - add py.typed; fix testing with lowest deps (#2458)
+
+### 📚 Documentation
+
+- Add pydoc configurations for Docusaurus (#2411)
+
+### ⚙️ CI
+
+- Install dependencies in the `test` environment when testing with lowest direct dependencies and Haystack main (#2418)
+
+### 🧹 Chores
+
+- Remove ruff exclude and fix linting in Langfuse integration (#2257)
+
+
+## [integrations/langfuse-v3.0.0] - 2025-09-19
+
+### 🌀 Miscellaneous
+
+- Migrate langfuse to v3 (#2247)
+
 ## [integrations/langfuse-v2.3.0] - 2025-08-25
 
 ### 🐛 Bug Fixes

{langfuse_haystack-3.0.0 → langfuse_haystack-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfuse-haystack
-Version: 3.0.0
+Version: 3.2.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<4.0.0,>=3.0.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-3.0.0 → langfuse_haystack-3.2.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-3.0.0 → langfuse_haystack-3.2.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.2.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-3.0.0 → langfuse_haystack-3.2.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>=3.0.0, <4.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"
@@ -67,24 +67,15 @@ dependencies = [
 unit = 'pytest -m "not integration" {args:tests}'
 integration = 'pytest -m "integration" {args:tests}'
 all = 'pytest {args:tests}'
-cov-retry = 'all --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x'
+cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x {args:tests}'
 
-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-3.0.0 → langfuse_haystack-3.2.0}/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -10,7 +10,7 @@ from contextlib import AbstractContextManager
 from contextvars import ContextVar
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, Iterator, List, Optional
+from typing import Any, Dict, Iterator, List, Literal, Optional
 
 from haystack import default_from_dict, default_to_dict, logging
 from haystack.dataclasses import ChatMessage
@@ -256,6 +256,46 @@ class SpanHandler(ABC):
         return default_to_dict(self)
 
 
+def _sanitize_usage_data(usage: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Sanitize usage data for Langfuse by flattening to a single-level dictionary.
+
+    Langfuse's usage_details must be a flat dictionary with only numeric values. This function:
+    - Flattens nested dictionaries using dot notation (e.g., cache_creation.input_tokens)
+    - Keeps int and float values
+    - Skips None, boolean, string, and other non-numeric types
+
+    :param usage: Raw usage dictionary from the provider.
+    :returns: Flat dictionary with only numeric values (int or float).
+    """
+    if not isinstance(usage, dict):
+        return {}
+
+    sanitized: Dict[str, Any] = {}
+
+    def _flatten(data: Dict[str, Any], prefix: str = "") -> None:
+        """Recursively flatten nested dictionaries."""
+        for key, value in data.items():
+            full_key = f"{prefix}.{key}" if prefix else key
+
+            if value is None:
+                # Skip None values (e.g., Anthropic's server_tool_use)
+                continue
+            elif isinstance(value, bool):
+                # Skip boolean values
+                continue
+            elif isinstance(value, (int, float)):
+                # Keep numeric values
+                sanitized[full_key] = value
+            elif isinstance(value, dict):
+                # Recursively flatten nested dicts
+                _flatten(value, full_key)
+            # Skip strings and other non-numeric types (e.g., Anthropic's service_tier)
+
+    _flatten(usage)
+    return sanitized
+
+
 class DefaultSpanHandler(SpanHandler):
     """DefaultSpanHandler provides the default Langfuse tracing behavior for Haystack."""
 
@@ -271,10 +311,12 @@ class DefaultSpanHandler(SpanHandler):
         # Get external tracing context for root trace creation (correlation metadata)
         tracing_ctx = tracing_context_var.get({})
         if not context.parent_span:
+            root_span_type: Literal["agent", "span"] = (
+                "agent" if context.operation_name == "haystack.agent.run" else "span"
+            )
             # Create a new trace when there's no parent span
-            span_context_manager = self.tracer.start_as_current_span(
-                name=context.trace_name,
-                version=tracing_ctx.get("version"),
+            span_context_manager = self.tracer.start_as_current_observation(
+                name=context.trace_name, version=tracing_ctx.get("version"), as_type=root_span_type
             )
 
             # Create LangfuseSpan which will handle entering the context manager
@@ -289,6 +331,7 @@ class DefaultSpanHandler(SpanHandler):
                 "metadata": None,
                 "tags": tracing_ctx.get("tags"),
                 "public": context.public,
+                "release": None,
             }
 
             # Filter out None values and apply trace attributes
@@ -297,6 +340,10 @@ class DefaultSpanHandler(SpanHandler):
                 span._span.update_trace(**trace_attrs)
 
             return span
+        elif context.component_type == "ToolInvoker":
+            return LangfuseSpan(self.tracer.start_as_current_observation(name=context.name, as_type="tool"))
+        elif context.operation_name == "haystack.agent.run":
+            return LangfuseSpan(self.tracer.start_as_current_observation(name=context.name, as_type="agent"))
         elif context.component_type in _ALL_SUPPORTED_GENERATORS:
             return LangfuseSpan(self.tracer.start_as_current_observation(name=context.name, as_type="generation"))
         else:
@@ -327,7 +374,9 @@ class DefaultSpanHandler(SpanHandler):
         if component_type in _SUPPORTED_GENERATORS:
             meta = span.get_data().get(_COMPONENT_OUTPUT_KEY, {}).get("meta")
             if meta:
-                span.raw_span().update(usage=meta[0].get("usage") or None, model=meta[0].get("model"))
+                usage = meta[0].get("usage")
+                sanitized_usage = _sanitize_usage_data(usage) if usage else None
+                span.raw_span().update(usage_details=sanitized_usage, model=meta[0].get("model"))
 
         if component_type in _SUPPORTED_CHAT_GENERATORS:
             replies = span.get_data().get(_COMPONENT_OUTPUT_KEY, {}).get("replies")
@@ -340,8 +389,10 @@ class DefaultSpanHandler(SpanHandler):
                     except ValueError:
                         logger.error(f"Failed to parse completion_start_time: {completion_start_time}")
                         completion_start_time = None
+                usage = meta.get("usage")
+                sanitized_usage = _sanitize_usage_data(usage) if usage else None
                 span.raw_span().update(
-                    usage=meta.get("usage") or None,
+                    usage_details=sanitized_usage,
                     model=meta.get("model"),
                     completion_start_time=completion_start_time,
                 )
@@ -465,11 +516,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_current_trace_id()
+        return self._tracer.get_current_trace_id() or ""

{langfuse_haystack-3.0.0 → langfuse_haystack-3.2.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 (
@@ -20,8 +18,8 @@ from haystack_integrations.tracing.langfuse.tracer import (
     LangfuseSpan,
     LangfuseTracer,
     SpanContext,
+    _sanitize_usage_data,
 )
-from haystack_integrations.components.connectors.langfuse import LangfuseConnector
 
 
 # Mock functions for Langfuse v3 API
@@ -78,7 +76,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)
 
@@ -92,10 +90,10 @@ class MockLangfuseClient:
     def __init__(self):
         self._mock_context_manager = MockContextManager()
 
-    def start_as_current_span(self, name=None, **kwargs):
+    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):
+    def start_as_current_observation(self, _name=None, _as_type=None, **_kwargs):
         return self._mock_context_manager
 
     def get_current_trace_id(self):
@@ -193,6 +191,41 @@ class TestSpanContext:
             )
 
 
+class TestSanitizeUsageData:
+    def test_anthropic_usage_flattens_and_filters(self):
+        """Test Anthropic's nested dict with None and strings gets flattened and filtered"""
+        usage = {
+            "cache_creation": {"ephemeral_1h_input_tokens": 0, "ephemeral_5m_input_tokens": 0},
+            "cache_creation_input_tokens": 0,
+            "cache_read_input_tokens": 0,
+            "server_tool_use": None,  # Should be filtered
+            "service_tier": "standard",  # Should be filtered
+            "prompt_tokens": 25,
+            "completion_tokens": 449,
+        }
+        result = _sanitize_usage_data(usage)
+        assert result == {
+            "cache_creation.ephemeral_1h_input_tokens": 0,
+            "cache_creation.ephemeral_5m_input_tokens": 0,
+            "cache_creation_input_tokens": 0,
+            "cache_read_input_tokens": 0,
+            "prompt_tokens": 25,
+            "completion_tokens": 449,
+        }
+
+    def test_openai_usage_preserved(self):
+        """Test OpenAI/Cohere flat dict with only numeric values works unchanged"""
+        usage = {"prompt_tokens": 29, "completion_tokens": 267, "total_tokens": 296}
+        result = _sanitize_usage_data(usage)
+        assert result == {"prompt_tokens": 29, "completion_tokens": 267, "total_tokens": 296}
+
+    def test_empty_and_invalid_input(self):
+        """Test edge cases return empty dict"""
+        assert _sanitize_usage_data({}) == {}
+        assert _sanitize_usage_data(None) == {}
+        assert _sanitize_usage_data({"only_strings": "value", "only_none": None}) == {}
+
+
 class TestDefaultSpanHandler:
     def test_handle_generator(self):
         mock_span = Mock()
@@ -206,7 +239,7 @@ class TestDefaultSpanHandler:
         handler.handle(mock_span, component_type="OpenAIGenerator")
 
         assert mock_span.update.call_count == 1
-        assert mock_span.update.call_args_list[0][1] == {"usage": None, "model": "test_model"}
+        assert mock_span.update.call_args_list[0][1] == {"usage_details": None, "model": "test_model"}
 
     def test_handle_chat_generator(self):
         mock_span = Mock()
@@ -228,9 +261,11 @@ class TestDefaultSpanHandler:
 
         assert mock_span.update.call_count == 1
         assert mock_span.update.call_args_list[0][1] == {
-            "usage": None,
+            "usage_details": 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):
@@ -255,7 +290,7 @@ class TestDefaultSpanHandler:
 
         assert mock_span.update.call_count == 1
         assert mock_span.update.call_args_list[0][1] == {
-            "usage": None,
+            "usage_details": None,
             "model": "test_model",
             "completion_start_time": None,
         }
@@ -302,18 +337,15 @@ 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, patch(
-            "haystack_integrations.tracing.langfuse.tracer.langfuse.get_client"
-        ) as mock_get_client:
-            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_client = mock_get_client()
             mock_context_manager = MockContextManager()
             mock_context_manager._span = mock_raw_span
-            mock_client.start_as_current_span.return_value = mock_context_manager
-
             mock_tracer = MagicMock()
+            mock_tracer.start_as_current_span.return_value = mock_context_manager
+
             tracer = LangfuseTracer(tracer=mock_tracer, name="Haystack", public=False)
 
             # check that the trace method is called on the tracer instance with the provided operation name and tags
@@ -329,9 +361,7 @@ 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):
-        with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client") as mock_get_client:
-            mock_client = mock_get_client()
-
+        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"}
@@ -340,9 +370,7 @@ class TestLangfuseTracer:
                 assert span.raw_span()._data["metadata"] == {"haystack.pipeline.output_data": "bye"}
 
     def test_trace_generation(self):
-        with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client") as mock_get_client:
-            mock_client = mock_get_client()
-
+        with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client"):
             tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)
             tags = {
                 "haystack.component.type": "OpenAIChatGenerator",
@@ -356,9 +384,9 @@ class TestLangfuseTracer:
             }
             with tracer.trace(operation_name="operation_name", tags=tags) as span:
                 ...
-            assert span.raw_span()._data["usage"] is None
+            assert span.raw_span()._data["usage_details"] 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)
+            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):
         """
@@ -402,7 +430,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}"
@@ -411,9 +439,7 @@ class TestLangfuseTracer:
         assert "weather_tool" in updated_name, f"Expected 'weather_tool' in {updated_name}"
 
     def test_trace_generation_invalid_start_time(self):
-        with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client") as mock_get_client:
-            mock_client = mock_get_client()
-
+        with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client"):
             tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)
             tags = {
                 "haystack.component.type": "OpenAIChatGenerator",
@@ -425,7 +451,7 @@ class TestLangfuseTracer:
             }
             with tracer.trace(operation_name="operation_name", tags=tags) as span:
                 ...
-            assert span.raw_span()._data["usage"] is None
+            assert span.raw_span()._data["usage_details"] is None
             assert span.raw_span()._data["model"] == "test_model"
             assert span.raw_span()._data["completion_start_time"] is None
 
@@ -434,7 +460,7 @@ class TestLangfuseTracer:
         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()
@@ -444,10 +470,11 @@ class TestLangfuseTracer:
         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()
@@ -456,7 +483,7 @@ class TestLangfuseTracer:
         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
@@ -471,7 +498,7 @@ 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=MockLangfuseClient(), name="Haystack", public=False)
             assert "tracing is disabled" in caplog.text

{langfuse_haystack-3.0.0 → langfuse_haystack-3.2.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,8 +17,17 @@ 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"
@@ -38,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
 
@@ -73,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}")
 
@@ -242,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