langfuse-haystack 2.1.0__tar.gz → 2.2.1__tar.gz

{langfuse_haystack-2.1.0 → langfuse_haystack-2.2.1}/CHANGELOG.md

@@ -1,10 +1,29 @@
 # Changelog
 
+## [integrations/langfuse-v2.2.0] - 2025-07-03
+
+### 🚀 Features
+
+- Simpler generation spans, use Haystack's to_openai_dict_format (#2044)
+
+### 🐛 Bug Fixes
+
+- Properly cleanup Langfuse tracing context after pipeline run failures (#1999)
+
+
+### 🧹 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
 
 ### 🚀 Features
 
-- Use Langfuse local _to_openai_dict_format function to serialize messages (#1885)
+- Use Langfuse local to_openai_dict_format function to serialize messages (#1885)
 
 ### 🌀 Miscellaneous
 

{langfuse_haystack-2.1.0 → langfuse_haystack-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfuse-haystack
-Version: 2.1.0
+Version: 2.2.1
 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,7 +18,7 @@ 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.13.0
+Requires-Dist: haystack-ai>=2.15.1
 Requires-Dist: langfuse<3.0.0,>=2.9.0
 Description-Content-Type: text/markdown
 

{langfuse_haystack-2.1.0 → langfuse_haystack-2.2.1}/pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.13.0", "langfuse>=2.9.0, <3.0.0"]
+dependencies = ["haystack-ai>=2.15.1", "langfuse>=2.9.0, <3.0.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse#readme"
@@ -79,7 +79,6 @@ installer = "uv"
 detached = true
 dependencies = [
     "pip",
-    "black>=23.1.0",
     "mypy>=1.0.0",
     "ruff>=0.0.243",
 ]
@@ -90,10 +89,6 @@ typing = "mypy --install-types --non-interactive --explicit-package-bases {args:
 [tool.hatch.metadata]
 allow-direct-references = true
 
-[tool.black]
-target-version = ["py38"]
-line-length = 120
-skip-string-normalization = true
 
 [tool.ruff]
 target-version = "py38"

{langfuse_haystack-2.1.0 → langfuse_haystack-2.2.1}/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -3,7 +3,6 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import contextlib
-import json
 import os
 from abc import ABC, abstractmethod
 from collections import Counter
@@ -39,6 +38,7 @@ _SUPPORTED_GENERATORS = [
     "OllamaGenerator",
 ]
 _SUPPORTED_CHAT_GENERATORS = [
+    "AmazonBedrockChatGenerator",
     "AzureOpenAIChatGenerator",
     "OpenAIChatGenerator",
     "AnthropicChatGenerator",
@@ -66,61 +66,6 @@ _COMPONENT_INPUT_KEY = "haystack.component.input"
 tracing_context_var: ContextVar[Dict[Any, Any]] = ContextVar("tracing_context")
 
 
-def _to_openai_dict_format(chat_message: ChatMessage) -> Dict[str, Any]:
-    """
-    Convert a ChatMessage to the dictionary format expected by OpenAI's chat completion API.
-
-    Note: We already have such a method in Haystack's ChatMessage class.
-    However, the original method doesn't tolerate None values for ids of ToolCall and ToolCallResult.
-    Some generators, like GoogleGenAIChatGenerator, return None values for ids of ToolCall and ToolCallResult.
-    To seamlessly support these generators, we use this, Langfuse local, version of the method.
-
-    :param chat_message: The ChatMessage instance to convert.
-    :return: Dictionary in OpenAI Chat API format.
-    """
-    text_contents = chat_message.texts
-    tool_calls = chat_message.tool_calls
-    tool_call_results = chat_message.tool_call_results
-
-    if not text_contents and not tool_calls and not tool_call_results:
-        message = "A `ChatMessage` must contain at least one `TextContent`, `ToolCall`, or `ToolCallResult`."
-        logger.error(message)
-        raise ValueError(message)
-    if len(text_contents) + len(tool_call_results) > 1:
-        message = "A `ChatMessage` can only contain one `TextContent` or one `ToolCallResult`."
-        logger.error(message)
-        raise ValueError(message)
-
-    openai_msg: Dict[str, Any] = {"role": chat_message._role.value}
-
-    # Add name field if present
-    if chat_message._name is not None:
-        openai_msg["name"] = chat_message._name
-
-    if tool_call_results:
-        result = tool_call_results[0]
-        openai_msg["content"] = result.result
-        openai_msg["tool_call_id"] = result.origin.id
-        # OpenAI does not provide a way to communicate errors in tool invocations, so we ignore the error field
-        return openai_msg
-
-    if text_contents:
-        openai_msg["content"] = text_contents[0]
-    if tool_calls:
-        openai_tool_calls = []
-        for tc in tool_calls:
-            openai_tool_calls.append(
-                {
-                    "id": tc.id,
-                    "type": "function",
-                    # We disable ensure_ascii so special chars like emojis are not converted
-                    "function": {"name": tc.tool_name, "arguments": json.dumps(tc.arguments, ensure_ascii=False)},
-                }
-            )
-        openai_msg["tool_calls"] = openai_tool_calls
-    return openai_msg
-
-
 class LangfuseSpan(Span):
     """
     Internal class representing a bridge between the Haystack span tracing API and Langfuse.
@@ -158,7 +103,7 @@ class LangfuseSpan(Span):
             return
         if key.endswith(".input"):
             if "messages" in value:
-                messages = [_to_openai_dict_format(m) for m in value["messages"]]
+                messages = [m.to_openai_dict_format(require_tool_call_ids=False) for m in value["messages"]]
                 self._span.update(input=messages)
             else:
                 coerced_value = tracing_utils.coerce_tag_value(value)
@@ -166,7 +111,7 @@ class LangfuseSpan(Span):
         elif key.endswith(".output"):
             if "replies" in value:
                 if all(isinstance(r, ChatMessage) for r in value["replies"]):
-                    replies = [_to_openai_dict_format(m) for m in value["replies"]]
+                    replies = [m.to_openai_dict_format(require_tool_call_ids=False) for m in value["replies"]]
                 else:
                     replies = value["replies"]
                 self._span.update(output=replies)
@@ -449,22 +394,33 @@ class LangfuseTracer(Tracer):
         self._context.append(span)
         span.set_tags(tags)
 
-        yield span
-
-        # Let the span handler process the span
-        self._span_handler.handle(span, component_type)
-
-        # In this section, we finalize both regular spans and generation spans created using the LangfuseSpan class.
-        # It's important to end() these spans to ensure they are properly closed and all relevant data is recorded.
-        # Note that we do not call end() on the main trace span itself (StatefulTraceClient), as its lifecycle is
-        # managed differently.
-        raw_span = span.raw_span()
-        if isinstance(raw_span, (StatefulSpanClient, StatefulGenerationClient)):
-            raw_span.end()
-        self._context.pop()
-
-        if self.enforce_flush:
-            self.flush()
+        try:
+            yield span
+        finally:
+            # Always clean up context, even if nested operations fail
+            try:
+                # Process span data (may fail with nested pipeline exceptions)
+                self._span_handler.handle(span, component_type)
+
+                # End span (may fail if span data is corrupted)
+                raw_span = span.raw_span()
+                if isinstance(raw_span, (StatefulSpanClient, StatefulGenerationClient)):
+                    raw_span.end()
+            except Exception as cleanup_error:
+                # Log cleanup errors but don't let them corrupt context
+                logger.warning(
+                    "Error during span cleanup for {operation_name}: {cleanup_error}",
+                    operation_name=operation_name,
+                    cleanup_error=cleanup_error,
+                )
+            finally:
+                # CRITICAL: Always pop context to prevent corruption
+                # This is especially important for nested pipeline scenarios
+                if self._context and self._context[-1] == span:
+                    self._context.pop()
+
+            if self.enforce_flush:
+                self.flush()
 
     def flush(self) -> None:
         self._tracer.flush()

{langfuse_haystack-2.1.0 → langfuse_haystack-2.2.1}/tests/test_tracer.py

@@ -3,15 +3,20 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import datetime
+import json
 import logging
 import sys
-from unittest.mock import MagicMock, Mock, patch
 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 LangfuseTracer, LangfuseSpan, SpanContext, DefaultSpanHandler
-from haystack_integrations.tracing.langfuse.tracer import _COMPONENT_OUTPUT_KEY
+
+from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+from haystack_integrations.tracing.langfuse.tracer import (
+    _COMPONENT_OUTPUT_KEY, DefaultSpanHandler, LangfuseSpan, LangfuseTracer,
+    SpanContext)
 
 
 class MockSpan:
@@ -367,7 +372,8 @@ class TestLangfuseTracer:
         monkeypatch.setenv("HAYSTACK_LANGFUSE_ENFORCE_FLUSH", "false")
         tracer_mock = Mock()
 
-        from haystack_integrations.tracing.langfuse.tracer import LangfuseTracer
+        from haystack_integrations.tracing.langfuse.tracer import \
+            LangfuseTracer
 
         tracer = LangfuseTracer(tracer=tracer_mock, name="Haystack", public=False)
         with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.input_data": "hello"}) as span:
@@ -397,3 +403,58 @@ class TestLangfuseTracer:
 
             LangfuseTracer(tracer=MockTracer(), name="Haystack", public=False)
             assert "tracing is disabled" in caplog.text
+
+    def test_context_cleanup_after_nested_failures(self):
+        """
+        Test that tracer context is properly cleaned up even when nested operations fail.
+
+        This test addresses a critical bug where failing nested operations (like inner pipelines)
+        could corrupt the tracing context, leaving stale spans that affect subsequent operations.
+        The fix ensures proper cleanup through try/finally blocks.
+
+        Before the fix: context would retain spans after failures (length > 0)
+        After the fix: context is always cleaned up (length == 0)
+        """
+
+
+        @component
+        class FailingParser:
+            @component.output_types(result=str)
+            def run(self, data: str):
+                # This will fail with ValueError when data is not valid JSON
+                parsed = json.loads(data)
+                return {"result": parsed["key"]}
+
+        @component
+        class ComponentWithNestedPipeline:
+            def __init__(self):
+                # This simulates IntentClassifier's internal pipeline
+                self.internal_pipeline = Pipeline()
+                self.internal_pipeline.add_component("parser", FailingParser())
+
+            @component.output_types(result=str)
+            def run(self, input_data: str):
+                # Run nested pipeline - this is where corruption occurs
+                result = self.internal_pipeline.run({"parser": {"data": input_data}})
+                return {"result": result["parser"]["result"]}
+
+        tracer = LangfuseConnector("test")
+
+        main_pipeline = Pipeline()
+        main_pipeline.add_component("nested_component", ComponentWithNestedPipeline())
+        main_pipeline.add_component("tracer", tracer)
+
+        # Test 1: First run will fail and should clean up context
+        try:
+            main_pipeline.run({"nested_component": {"input_data": "invalid json"}})
+        except Exception:
+            pass  # Expected to fail
+
+        # Critical assertion: context should be empty after failed operation
+        assert len(tracer.tracer._context) == 0
+
+        # 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