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

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

@@ -1,5 +1,24 @@
 # 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfuse-haystack
-Version: 3.1.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

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

@@ -67,7 +67,7 @@ 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 -p haystack_integrations.components.connectors.langfuse -p haystack_integrations.tracing.langfuse {args}"
 

{langfuse_haystack-3.1.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
@@ -298,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:
@@ -328,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")
@@ -341,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,
                 )

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

@@ -18,6 +18,7 @@ from haystack_integrations.tracing.langfuse.tracer import (
     LangfuseSpan,
     LangfuseTracer,
     SpanContext,
+    _sanitize_usage_data,
 )
 
 
@@ -190,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()
@@ -203,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()
@@ -225,7 +261,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": datetime.datetime(  # noqa: DTZ001
                 2021, 7, 27, 16, 2, 8, 12345
@@ -254,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,
         }
@@ -348,7 +384,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"] == datetime.datetime(2021, 7, 27, 16, 2, 8, 12345)  # noqa: DTZ001
 
@@ -415,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