langfuse-haystack 5.1.0__tar.gz → 6.0.0__tar.gz

{langfuse_haystack-5.1.0 → langfuse_haystack-6.0.0}/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [integrations/langfuse-v5.2.0] - 2026-07-15
+
+### 🐛 Bug Fixes
+
+- *(langfuse)* Replace noisy ToolInvoker input with focused tool call arguments (#3520)
+
+
+## [integrations/langfuse-v5.1.0] - 2026-07-08
+
+### 🐛 Bug Fixes
+
+- *(langfuse)* Stop relying on `haystack.utils.base_serialization` helpers (#3563)
+
+### 📚 Documentation
+
+- Replace old haystack core imports with haystack_integrations paths (#3545)
+
+### 🧪 Testing
+
+- Trust test modules under Haystack 3.0's deserialization allowlist (#3537)
+
+### 🧹 Chores
+
+- Improve consistency of integrations folder structure (#3430)
+
+
 ## [integrations/langfuse-v5.0.2] - 2026-06-01
 
 ### 🐛 Bug Fixes
@@ -165,14 +191,19 @@
 
 - Properly cleanup Langfuse tracing context after pipeline run failures (#1999)
 
+### 🧹 Chores
+
+- Remove black (#1985)
+
+
+## [integrations/langfuse-v2.1.0] - 2025-06-16
+
 
 ### 🧹 Chores
 
 - Pin langfuse<3.0.0 (#1904)
 - Align core-integrations Hatch scripts (#1898)
 - Update md files for new hatch scripts (#1911)
-- Remove black (#1985)
-
 
 ## [integrations/langfuse-v2.0.1] - 2025-06-02
 
@@ -229,10 +260,15 @@
 
 ### 🚀 Features
 
-- Adapt Ollama metadata to OpenAI format; support Ollama in Langfuse (#1577)
 - Unify traces of sub-pipelines within pipelines with Langfuse (#1624)
 
 
+## [integrations/langfuse-v0.10.0] - 2025-04-04
+
+### 🚀 Features
+
+- Adapt Ollama metadata to OpenAI format; support Ollama in Langfuse (#1577)
+
 
 ## [integrations/langfuse-v0.9.0] - 2025-04-04
 
@@ -292,6 +328,12 @@
 
 ## [integrations/langfuse-v0.6.2] - 2025-01-02
 
+### 🌀 Miscellaneous
+
+- Fix messages conversion to OpenAI format (#1272)
+
+## [integrations/langfuse-v0.6.1] - 2024-12-11
+
 ### 🚀 Features
 
 - Warn if LangfuseTracer initialized without tracing enabled (#1231)
@@ -303,7 +345,6 @@
 ### 🌀 Miscellaneous
 
 - Chore: Fix tracing_context_var lint errors (#1220)
-- Fix messages conversion to OpenAI format (#1272)
 
 ## [integrations/langfuse-v0.6.0] - 2024-11-18
 
@@ -336,6 +377,9 @@
 
 - Langfuse - support generation span for more LLMs (#1087)
 
+
+## [integrations/langfuse-v0.3.0] - 2024-09-11
+
 ### 🚜 Refactor
 
 - Remove usage of deprecated `ChatMessage.to_openai_format` (#1001)
@@ -371,10 +415,6 @@
 
 ## [integrations/langfuse-v0.1.0] - 2024-06-13
 
-### 🚀 Features
-
-- Langfuse integration (#686)
-
 ### 🐛 Bug Fixes
 
 - Performance optimizations and value error when streaming in langfuse (#798)
@@ -388,4 +428,10 @@
 - Chore: change the pydoc renderer class (#718)
 - Docs: add missing api references (#728)
 
+## [integrations/langfuse-v0.0.4] - 2024-05-02
+
+### 🚀 Features
+
+- Langfuse integration (#686)
+
 <!-- generated by git-cliff -->

{langfuse_haystack-5.1.0 → langfuse_haystack-6.0.0}/LICENSE.txt

@@ -58,7 +58,7 @@ APPENDIX: How to apply the Apache License to your work.
 
 To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
 
-Copyright [yyyy] [name of copyright owner]
+Copyright 2023-present deepset GmbH
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

{langfuse_haystack-5.1.0 → langfuse_haystack-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: langfuse-haystack
-Version: 5.1.0
+Version: 6.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
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.13
 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: haystack-ai>=3.0.0
 Requires-Dist: langfuse>=4.0.0
 Description-Content-Type: text/markdown
 

{langfuse_haystack-5.1.0 → langfuse_haystack-6.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>=4.0.0"]
+dependencies = ["haystack-ai>=3.0.0", "langfuse>=4.0.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse#readme"
@@ -130,6 +130,7 @@ ignore = [
   "PLR0912",
   "PLR0913",
   "PLR0915",
+  "PLR0917",
   # Asserts
   "S101",
   # Allow `Any` - used legitimately for dynamic types and SDK boundaries

{langfuse_haystack-5.1.0 → langfuse_haystack-6.0.0}/src/haystack_integrations/components/connectors/langfuse/langfuse_connector.py

@@ -157,18 +157,28 @@ class LangfuseConnector:
         self.span_handler = span_handler
         self.host = host
         self.langfuse_client_kwargs = langfuse_client_kwargs
+        self._httpx_client = httpx_client
+        self.tracer: LangfuseTracer | None = None
+
+    def warm_up(self) -> None:
+        """
+        Initialize the Langfuse client and enable tracing once.
+        """
+        if self.tracer is not None:
+            return
+
         resolved_langfuse_client_kwargs = {
-            "secret_key": secret_key.resolve_value() if secret_key else None,
-            "public_key": public_key.resolve_value() if public_key else None,
-            "httpx_client": httpx_client,
-            "host": host,
-            **(langfuse_client_kwargs or {}),
+            "secret_key": self.secret_key.resolve_value() if self.secret_key else None,
+            "public_key": self.public_key.resolve_value() if self.public_key else None,
+            "httpx_client": self._httpx_client,
+            "host": self.host,
+            **(self.langfuse_client_kwargs or {}),
         }
         self.tracer = LangfuseTracer(
             tracer=Langfuse(**resolved_langfuse_client_kwargs),
-            name=name,
-            public=public,
-            span_handler=span_handler,
+            name=self.name,
+            public=self.public,
+            span_handler=self.span_handler,
         )
         tracing.enable_tracing(self.tracer)
 
@@ -186,6 +196,8 @@ class LangfuseConnector:
             - `trace_url`: The URL to the tracing data.
             - `trace_id`: The ID of the trace.
         """
+        self.warm_up()
+        assert self.tracer is not None
         logger.debug(
             "Langfuse tracer invoked with the following context: '{invocation_context}'",
             invocation_context=invocation_context,

{langfuse_haystack-5.1.0 → langfuse_haystack-6.0.0}/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -345,10 +345,13 @@ class DefaultSpanHandler(SpanHandler):
         # special case for ToolInvoker (to update the span name to be: `original_component_name - [tool_names]`)
         if component_type == "ToolInvoker":
             tool_names: list[str] = []
+            tool_calls_input: list[dict[str, Any]] = []
             messages = span.get_data().get(_COMPONENT_INPUT_KEY, {}).get("messages", [])
             for message in messages:
                 if isinstance(message, ChatMessage) and message.tool_calls:
-                    tool_names.extend(call.tool_name for call in message.tool_calls)
+                    for call in message.tool_calls:
+                        tool_names.append(call.tool_name)
+                        tool_calls_input.append({"tool_name": call.tool_name, "arguments": call.arguments})
 
             if tool_names:
                 # Fallback to "ToolInvoker" if we can't retrieve component name
@@ -357,6 +360,30 @@ class DefaultSpanHandler(SpanHandler):
                 formatted_names = [f"{name} (x{count})" if count > 1 else name for name, count in tool_counts.items()]
                 span.raw_span().update(name=f"{tool_invoker_name} - {sorted(formatted_names)}")
 
+            if tool_calls_input and proxy_tracer.is_content_tracing_enabled:
+                # Replace the noisy full message history with just the tool call arguments
+                span.raw_span().update(input=tool_calls_input)
+
+                output_messages = span.get_data().get(_COMPONENT_OUTPUT_KEY, {}).get("tool_messages", [])
+                tool_results: list[dict[str, Any]] = []
+                for message in output_messages:
+                    if isinstance(message, ChatMessage) and message.tool_call_results:
+                        for tcr in message.tool_call_results:
+                            origin = tcr.origin
+                            # Keys `name`, `arguments` and `id` let Langfuse detect these as tool
+                            # calls at ingestion and populate the Tool Call Name filter in the UI.
+                            tool_results.append(
+                                {
+                                    "id": origin.id if origin else None,
+                                    "name": origin.tool_name if origin else None,
+                                    "arguments": origin.arguments if origin else None,
+                                    "result": tcr.result,
+                                    "error": tcr.error,
+                                }
+                            )
+                if tool_results:
+                    span.raw_span().update(output=tool_results)
+
         if component_type and component_type.endswith("ChatGenerator"):
             replies = span.get_data().get(_COMPONENT_OUTPUT_KEY, {}).get("replies")
             if replies:

{langfuse_haystack-5.1.0 → langfuse_haystack-6.0.0}/tests/test_langfuse_connector.py

@@ -6,48 +6,53 @@ import os
 
 os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
 
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
 
-from haystack import Pipeline
+import httpx
+import pytest
+from haystack import Pipeline, tracing
 from haystack.components.builders import ChatPromptBuilder
 from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.tracing.tracer import NullTracer
 from haystack.utils import Secret
 
 from haystack_integrations.components.connectors.langfuse import LangfuseConnector
 from haystack_integrations.tracing.langfuse import DefaultSpanHandler
 
 
+@pytest.fixture
+def mock_langfuse(monkeypatch):
+    monkeypatch.setattr(tracing.tracer, "actual_tracer", NullTracer())
+    with patch("haystack_integrations.components.connectors.langfuse.langfuse_connector.Langfuse") as constructor:
+        constructor.return_value.get_trace_url.return_value = "https://example.com/trace"
+        constructor.return_value.get_current_trace_id.return_value = "12345"
+        yield constructor
+
+
 class CustomSpanHandler(DefaultSpanHandler):
     def handle(self, span, component_type=None):
         pass
 
 
-class TestLangfuseConnector:
-    def test_run(self, monkeypatch):
-        monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")
-        monkeypatch.setenv("LANGFUSE_PUBLIC_KEY", "public")
-
+class TestRun:
+    def test_run(self, mock_langfuse):
         langfuse_connector = LangfuseConnector(
             name="Chat example - OpenAI",
             public=True,
-            secret_key=Secret.from_env_var("LANGFUSE_SECRET_KEY"),
-            public_key=Secret.from_env_var("LANGFUSE_PUBLIC_KEY"),
+            secret_key=Secret.from_token("secret"),
+            public_key=Secret.from_token("public"),
         )
 
-        mock_tracer = Mock()
-        mock_tracer.get_trace_url.return_value = "https://example.com/trace"
-        mock_tracer.get_trace_id.return_value = "12345"
-        langfuse_connector.tracer = mock_tracer
-
         response = langfuse_connector.run(invocation_context={"some_key": "some_value"})
         assert response["name"] == "Chat example - OpenAI"
         assert response["trace_url"] == "https://example.com/trace"
         assert response["trace_id"] == "12345"
+        mock_langfuse.assert_called_once()
+        assert tracing.tracer.actual_tracer is langfuse_connector.tracer
 
-    def test_to_dict(self, monkeypatch):
-        monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")
-        monkeypatch.setenv("LANGFUSE_PUBLIC_KEY", "public")
 
+class TestSerialization:
+    def test_to_dict(self):
         langfuse_connector = LangfuseConnector(name="Chat example - OpenAI")
         serialized = langfuse_connector.to_dict()
 
@@ -72,10 +77,7 @@ class TestLangfuseConnector:
             },
         }
 
-    def test_to_dict_with_params(self, monkeypatch):
-        monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")
-        monkeypatch.setenv("LANGFUSE_PUBLIC_KEY", "public")
-
+    def test_to_dict_with_params(self):
         langfuse_connector = LangfuseConnector(
             name="Chat example - OpenAI",
             public=True,
@@ -111,10 +113,7 @@ class TestLangfuseConnector:
             },
         }
 
-    def test_from_dict(self, monkeypatch):
-        monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")
-        monkeypatch.setenv("LANGFUSE_PUBLIC_KEY", "public")
-
+    def test_from_dict(self):
         data = {
             "type": "haystack_integrations.components.connectors.langfuse.langfuse_connector.LangfuseConnector",
             "init_parameters": {
@@ -144,10 +143,7 @@ class TestLangfuseConnector:
         assert langfuse_connector.host is None
         assert langfuse_connector.langfuse_client_kwargs is None
 
-    def test_from_dict_without_span_handler(self, monkeypatch):
-        monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")
-        monkeypatch.setenv("LANGFUSE_PUBLIC_KEY", "public")
-
+    def test_from_dict_without_span_handler(self):
         # All keys that would point to None (span_handler, host, langfuse_client_kwargs) are intentionally absent
         data = {
             "type": "haystack_integrations.components.connectors.langfuse.langfuse_connector.LangfuseConnector",
@@ -175,10 +171,7 @@ class TestLangfuseConnector:
         assert langfuse_connector.host is None
         assert langfuse_connector.langfuse_client_kwargs is None
 
-    def test_from_dict_with_params(self, monkeypatch):
-        monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")
-        monkeypatch.setenv("LANGFUSE_PUBLIC_KEY", "public")
-
+    def test_from_dict_with_params(self):
         data = {
             "type": "haystack_integrations.components.connectors.langfuse.langfuse_connector.LangfuseConnector",
             "init_parameters": {
@@ -212,10 +205,8 @@ class TestLangfuseConnector:
         assert langfuse_connector.host == "https://example.com"
         assert langfuse_connector.langfuse_client_kwargs == {"timeout": 30.0}
 
-    def test_from_dict_with_legacy_span_handler_format(self, monkeypatch):
+    def test_from_dict_with_legacy_span_handler_format(self):
         # Pipelines serialized before this fix wrap span_handler as {"type": ..., "data": {...}}
-        monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")
-        monkeypatch.setenv("LANGFUSE_PUBLIC_KEY", "public")
 
         data = {
             "type": "haystack_integrations.components.connectors.langfuse.langfuse_connector.LangfuseConnector",
@@ -249,8 +240,6 @@ class TestLangfuseConnector:
 
     def test_pipeline_serialization(self, monkeypatch):
         # Set test env vars
-        monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")
-        monkeypatch.setenv("LANGFUSE_PUBLIC_KEY", "public")
         monkeypatch.setenv("OPENAI_API_KEY", "openai_api_key")
 
         # Create pipeline with OpenAI LLM
@@ -285,3 +274,54 @@ class TestLangfuseConnector:
 
         # Verify pipeline is the same
         assert new_pipe == pipe
+
+
+class TestComponentLifecycle:
+    @pytest.mark.parametrize("key", ["LANGFUSE_SECRET_KEY", "LANGFUSE_PUBLIC_KEY"])
+    def test_key_resolved_at_warm_up_not_init(self, key, monkeypatch, mock_langfuse):
+        monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")
+        monkeypatch.setenv("LANGFUSE_PUBLIC_KEY", "public")
+        monkeypatch.delenv(key)
+        connector = LangfuseConnector("test")
+        assert connector.tracer is None
+        mock_langfuse.assert_not_called()
+        assert not tracing.is_tracing_enabled()
+
+        with pytest.raises(ValueError, match=key):
+            connector.warm_up()
+        assert connector.tracer is None
+        mock_langfuse.assert_not_called()
+
+        monkeypatch.setenv(key, "available-now")
+        connector.warm_up()
+        assert connector.tracer is not None
+        mock_langfuse.assert_called_once()
+
+    def test_warm_up_passes_configuration_and_is_idempotent(self, mock_langfuse):
+        client = Mock(spec=httpx.Client)
+        handler = CustomSpanHandler()
+        connector = LangfuseConnector(
+            "configured",
+            public=True,
+            public_key=Secret.from_token("public"),
+            secret_key=Secret.from_token("secret"),
+            httpx_client=client,
+            span_handler=handler,
+            host="https://example.com",
+            langfuse_client_kwargs={"timeout": 30, "host": "https://override.example.com"},
+        )
+        connector.warm_up()
+        first_tracer = connector.tracer
+        connector.warm_up()
+        assert connector.tracer is first_tracer
+        mock_langfuse.assert_called_once_with(
+            public_key="public",
+            secret_key="secret",
+            httpx_client=client,
+            host="https://override.example.com",
+            timeout=30,
+        )
+        assert handler.tracer is mock_langfuse.return_value
+        assert connector.tracer is not None
+        assert connector.tracer._name == "configured"
+        assert connector.tracer._public is True

{langfuse_haystack-5.1.0 → langfuse_haystack-6.0.0}/tests/test_tracer.py

@@ -748,6 +748,79 @@ class TestLangfuseTracer:
         assert "search_tool (x2)" in updated_name, f"Expected 'search_tool (x2)' in {updated_name}"
         assert "weather_tool" in updated_name, f"Expected 'weather_tool' in {updated_name}"
 
+    def test_handle_tool_invoker_input_output_with_content_tracing(self):
+        """
+        Test that ToolInvoker spans replace the noisy full-message input with just tool call
+        arguments, and populate output with tool results, when content tracing is enabled.
+        """
+        mock_span = Mock()
+        mock_span.raw_span.return_value = mock_span
+
+        tool_call = ToolCall(id="call_123", tool_name="search_tool", arguments={"query": "RAG pipelines"})
+
+        span_data = {
+            "haystack.component.name": "tool_invoker",
+            "haystack.component.type": "ToolInvoker",
+            "haystack.component.input": {
+                "messages": [
+                    ChatMessage.from_user("what is RAG?"),
+                    ChatMessage.from_assistant(text="Calling search", tool_calls=[tool_call]),
+                ]
+            },
+            "haystack.component.output": {
+                "tool_messages": [ChatMessage.from_tool("RAG stands for Retrieval-Augmented Generation", tool_call)]
+            },
+        }
+        mock_span.get_data.return_value = span_data
+
+        handler = DefaultSpanHandler()
+        with patch("haystack_integrations.tracing.langfuse.tracer.proxy_tracer.is_content_tracing_enabled", True):
+            handler.handle(mock_span, component_type="ToolInvoker")
+
+        update_calls = {k: v for call in mock_span.update.call_args_list for k, v in call[1].items()}
+
+        # input should be just the tool call arguments, not the full message list
+        assert update_calls["input"] == [{"tool_name": "search_tool", "arguments": {"query": "RAG pipelines"}}]
+        # output carries id/name/arguments so Langfuse detects the tool call and populates its filter
+        assert update_calls["output"] == [
+            {
+                "id": "call_123",
+                "name": "search_tool",
+                "arguments": {"query": "RAG pipelines"},
+                "result": "RAG stands for Retrieval-Augmented Generation",
+                "error": False,
+            }
+        ]
+
+    def test_handle_tool_invoker_no_content_tracing(self):
+        """
+        Test that ToolInvoker input/output is NOT updated when content tracing is disabled.
+        The span name update (tool names) should still happen.
+        """
+        mock_span = Mock()
+        mock_span.raw_span.return_value = mock_span
+
+        tool_call = ToolCall(tool_name="weather_tool", arguments={"location": "Tokyo"})
+
+        span_data = {
+            "haystack.component.name": "tool_invoker",
+            "haystack.component.type": "ToolInvoker",
+            "haystack.component.input": {"messages": [ChatMessage.from_assistant(text="", tool_calls=[tool_call])]},
+            "haystack.component.output": {"tool_messages": [ChatMessage.from_tool("Sunny, 28°C", tool_call)]},
+        }
+        mock_span.get_data.return_value = span_data
+
+        handler = DefaultSpanHandler()
+        with patch("haystack_integrations.tracing.langfuse.tracer.proxy_tracer.is_content_tracing_enabled", False):
+            handler.handle(mock_span, component_type="ToolInvoker")
+
+        update_kwargs_keys = {k for call in mock_span.update.call_args_list for k in call[1]}
+        # name should still be updated
+        assert "name" in update_kwargs_keys
+        # input and output must NOT be set when content tracing is off
+        assert "input" not in update_kwargs_keys
+        assert "output" not in update_kwargs_keys
+
     def test_trace_generation_invalid_start_time(self):
         with patch("haystack_integrations.tracing.langfuse.tracer.langfuse.get_client"):
             tracer = LangfuseTracer(tracer=MockLangfuseClient(), name="Haystack", public=False)