langfuse-haystack 5.0.2__tar.gz → 5.2.0__tar.gz

{langfuse_haystack-5.0.2 → langfuse_haystack-5.2.0}/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [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
+
+- Update langfuse deserialization to not require `span_handler` key (#3378)
+
+
 ## [integrations/langfuse-v5.0.1] - 2026-05-18
 
 ### 🐛 Bug Fixes

{langfuse_haystack-5.0.2 → langfuse_haystack-5.2.0}/PKG-INFO

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

@@ -6,12 +6,15 @@ os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
 from datasets import load_dataset
 from haystack import Document, Pipeline
 from haystack.components.builders import PromptBuilder
-from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
 from haystack.components.generators import OpenAIGenerator
 from haystack.components.retrievers import InMemoryEmbeddingRetriever
 from haystack.document_stores.in_memory import InMemoryDocumentStore
 
 from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+from haystack_integrations.components.embedders.sentence_transformers import (
+    SentenceTransformersDocumentEmbedder,
+    SentenceTransformersTextEmbedder,
+)
 
 
 def get_pipeline(document_store: InMemoryDocumentStore):
@@ -54,7 +57,6 @@ if __name__ == "__main__":
     document_store = InMemoryDocumentStore()
     dataset = load_dataset("bilgeyucel/seven-wonders", split="train")
     embedder = SentenceTransformersDocumentEmbedder("sentence-transformers/all-MiniLM-L6-v2")
-    embedder.warm_up()
     docs_with_embeddings = embedder.run([Document(**ds) for ds in dataset]).get("documents") or []  # type: ignore
     document_store.write_documents(docs_with_embeddings)
 

{langfuse_haystack-5.0.2 → langfuse_haystack-5.2.0}/example/chat.py

@@ -9,7 +9,7 @@ os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
 
 from haystack import Pipeline
 from haystack.components.builders import ChatPromptBuilder
-from haystack.components.generators.chat import HuggingFaceAPIChatGenerator, OpenAIChatGenerator
+from haystack.components.generators.chat import OpenAIChatGenerator
 from haystack.dataclasses import ChatMessage
 from haystack.utils.auth import Secret
 from haystack.utils.hf import HFGenerationAPIType
@@ -17,6 +17,7 @@ from haystack.utils.hf import HFGenerationAPIType
 from haystack_integrations.components.connectors.langfuse import LangfuseConnector
 from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator
 from haystack_integrations.components.generators.cohere import CohereChatGenerator
+from haystack_integrations.components.generators.huggingface_api import HuggingFaceAPIChatGenerator
 
 os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
 

{langfuse_haystack-5.0.2 → langfuse_haystack-5.2.0}/src/haystack_integrations/components/connectors/langfuse/langfuse_connector.py

@@ -6,11 +6,11 @@ from typing import Any
 
 import httpx
 from haystack import component, default_from_dict, default_to_dict, logging, tracing
-from haystack.utils import Secret, deserialize_secrets_inplace
-from haystack.utils.base_serialization import deserialize_class_instance, serialize_class_instance
-from langfuse import Langfuse
+from haystack.core.serialization import component_to_dict
+from haystack.utils import Secret, deserialize_chatgenerator_inplace, deserialize_secrets_inplace
 
 from haystack_integrations.tracing.langfuse import LangfuseTracer, SpanHandler
+from langfuse import Langfuse
 
 logger = logging.getLogger(__name__)
 
@@ -198,7 +198,7 @@ class LangfuseConnector:
 
         :returns: The serialized component as a dictionary.
         """
-        span_handler = serialize_class_instance(self.span_handler) if self.span_handler else None
+        span_handler = component_to_dict(self.span_handler, "span_handler") if self.span_handler else None
         if self.langfuse_client_kwargs:
             # pop httpx_client and mask from self._langfuse_client_kwargs to prevent serialization issues
             langfuse_client_kwargs = {
@@ -228,6 +228,12 @@ class LangfuseConnector:
         """
         init_params = data["init_parameters"]
         deserialize_secrets_inplace(init_params, keys=["secret_key", "public_key"])
-        if init_params.get("span_handler") is not None:
-            init_params["span_handler"] = deserialize_class_instance(init_params["span_handler"])
+        span_handler_data = init_params.get("span_handler")
+        if span_handler_data is not None:
+            if "data" in span_handler_data:
+                # Pipelines serialized before this fix wrap the span handler as
+                # {"type": ..., "data": {"type": ..., "init_parameters": ...}}; unwrap it here so older
+                # serialized pipelines keep working.
+                init_params["span_handler"] = span_handler_data["data"]
+            deserialize_chatgenerator_inplace(init_params, key="span_handler")
         return default_from_dict(cls, data)

{langfuse_haystack-5.0.2 → langfuse_haystack-5.2.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.2.0/tests/conftest.py

@@ -0,0 +1,11 @@
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def allow_deserialization_of_test_modules(monkeypatch):
+    """
+    haystack-ai >= 3.0 refuses to deserialize classes and callables from modules outside its
+    trusted-module allowlist. Tools and callbacks defined in the test modules live outside that
+    allowlist, so trust them explicitly; haystack-ai 2.x ignores this environment variable.
+    """
+    monkeypatch.setenv("HAYSTACK_DESERIALIZATION_ALLOWLIST", "tests,test_*")

{langfuse_haystack-5.0.2 → langfuse_haystack-5.2.0}/tests/test_langfuse_connector.py

@@ -104,10 +104,7 @@ class TestLangfuseConnector:
                 },
                 "span_handler": {
                     "type": "tests.test_langfuse_connector.CustomSpanHandler",
-                    "data": {
-                        "type": "tests.test_langfuse_connector.CustomSpanHandler",
-                        "init_parameters": {},
-                    },
+                    "init_parameters": {},
                 },
                 "host": "https://example.com",
                 "langfuse_client_kwargs": {"timeout": 30.0},
@@ -199,10 +196,7 @@ class TestLangfuseConnector:
                 },
                 "span_handler": {
                     "type": "tests.test_langfuse_connector.CustomSpanHandler",
-                    "data": {
-                        "type": "tests.test_langfuse_connector.CustomSpanHandler",
-                        "init_parameters": {},
-                    },
+                    "init_parameters": {},
                 },
                 "host": "https://example.com",
                 "langfuse_client_kwargs": {"timeout": 30.0},
@@ -218,6 +212,41 @@ 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):
+        # 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",
+            "init_parameters": {
+                "name": "Chat example - OpenAI",
+                "public": True,
+                "secret_key": {
+                    "type": "env_var",
+                    "env_vars": ["LANGFUSE_SECRET_KEY"],
+                    "strict": True,
+                },
+                "public_key": {
+                    "type": "env_var",
+                    "env_vars": ["LANGFUSE_PUBLIC_KEY"],
+                    "strict": True,
+                },
+                "span_handler": {
+                    "type": "tests.test_langfuse_connector.CustomSpanHandler",
+                    "data": {
+                        "type": "tests.test_langfuse_connector.CustomSpanHandler",
+                        "init_parameters": {},
+                    },
+                },
+                "host": "https://example.com",
+                "langfuse_client_kwargs": {"timeout": 30.0},
+            },
+        }
+
+        langfuse_connector = LangfuseConnector.from_dict(data)
+        assert isinstance(langfuse_connector.span_handler, CustomSpanHandler)
+
     def test_pipeline_serialization(self, monkeypatch):
         # Set test env vars
         monkeypatch.setenv("LANGFUSE_SECRET_KEY", "secret")

{langfuse_haystack-5.0.2 → langfuse_haystack-5.2.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)

langfuse_haystack-5.0.2/src/haystack_integrations/components/connectors/__init__.py

@@ -1,3 +0,0 @@
-# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0