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

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

@@ -1,5 +1,12 @@
 # Changelog
 
+## [integrations/langfuse-v2.2.1] - 2025-08-07
+
+### 🚀 Features
+
+- Add AmazonBedrockChatGenerator to supported chat generators in Langfuse (#2164)
+
+
 ## [integrations/langfuse-v2.2.0] - 2025-07-03
 
 ### 🚀 Features

langfuse_haystack-2.3.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: langfuse-haystack
+Version: 2.3.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
+Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse
+Author-email: deepset GmbH <info@deepset.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+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<3.0.0,>=2.9.0
+Description-Content-Type: text/markdown
+
+# langfuse-haystack
+
+[![PyPI - Version](https://img.shields.io/pypi/v/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
+
+- [Integration page](https://haystack.deepset.ai/integrations/langfuse)
+- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/langfuse/CHANGELOG.md)
+
+---
+
+## Contributing
+
+Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
+
+To run integration tests locally, you need to export the following environment variables:
+
+- `LANGFUSE_SECRET_KEY`
+- `LANGFUSE_PUBLIC_KEY`
+- `OPENAI_API_KEY`
+- `ANTHROPIC_API_KEY`
+- `COHERE_API_KEY`.

langfuse_haystack-2.3.0/README.md

@@ -0,0 +1,21 @@
+# langfuse-haystack
+
+[![PyPI - Version](https://img.shields.io/pypi/v/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
+
+- [Integration page](https://haystack.deepset.ai/integrations/langfuse)
+- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/langfuse/CHANGELOG.md)
+
+---
+
+## Contributing
+
+Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
+
+To run integration tests locally, you need to export the following environment variables:
+
+- `LANGFUSE_SECRET_KEY`
+- `LANGFUSE_PUBLIC_KEY`
+- `OPENAI_API_KEY`
+- `ANTHROPIC_API_KEY`
+- `COHERE_API_KEY`.

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

@@ -61,10 +61,14 @@ _COMPONENT_TYPE_KEY = "haystack.component.type"
 _COMPONENT_OUTPUT_KEY = "haystack.component.output"
 _COMPONENT_INPUT_KEY = "haystack.component.input"
 
-# Context var used to keep track of tracing related info.
-# This mainly useful for parents spans.
+# External session metadata for trace correlation (Haystack system)
+# Stores trace_id, user_id, session_id, tags, version for root trace creation
 tracing_context_var: ContextVar[Dict[Any, Any]] = ContextVar("tracing_context")
 
+# Internal span execution hierarchy for our tracer
+# Manages parent-child relationships and prevents cross-request span interleaving
+span_stack_var: ContextVar[Optional[List["LangfuseSpan"]]] = ContextVar("span_stack", default=None)
+
 
 class LangfuseSpan(Span):
     """
@@ -265,6 +269,7 @@ class DefaultSpanHandler(SpanHandler):
             )
             raise RuntimeError(message)
 
+        # Get external tracing context for root trace creation (correlation metadata)
         tracing_ctx = tracing_context_var.get({})
         if not context.parent_span:
             # Create a new trace when there's no parent span
@@ -360,6 +365,7 @@ class LangfuseTracer(Tracer):
                 "before importing Haystack."
             )
         self._tracer = tracer
+        # Keep _context as deprecated shim to avoid AttributeError if anyone uses it
         self._context: List[LangfuseSpan] = []
         self._name = name
         self._public = public
@@ -391,7 +397,12 @@ class LangfuseTracer(Tracer):
         # Create span using the handler
         span = self._span_handler.create_span(span_context)
 
-        self._context.append(span)
+        # Build new span hierarchy: copy existing stack, add new span, save for restoration
+        prev_stack = span_stack_var.get()
+        new_stack = (prev_stack or []).copy()
+        new_stack.append(span)
+        token = span_stack_var.set(new_stack)
+
         span.set_tags(tags)
 
         try:
@@ -414,10 +425,8 @@ class LangfuseTracer(Tracer):
                     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()
+                # Restore previous span stack using saved token - ensures proper cleanup
+                span_stack_var.reset(token)
 
             if self.enforce_flush:
                 self.flush()
@@ -431,7 +440,9 @@ class LangfuseTracer(Tracer):
 
         :return: The current span if available, else None.
         """
-        return self._context[-1] if self._context else None
+        # Get top of span stack (most recent span) from context-local storage
+        stack = span_stack_var.get()
+        return stack[-1] if stack else None
 
     def get_trace_url(self) -> str:
         """

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

@@ -2,10 +2,11 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import asyncio
 import datetime
-import json
 import logging
 import sys
+import json
 from typing import Optional
 from unittest.mock import MagicMock, Mock, patch
 
@@ -13,40 +14,45 @@ import pytest
 from haystack import Pipeline, component
 from haystack.dataclasses import ChatMessage, ToolCall
 
-from haystack_integrations.components.connectors.langfuse import LangfuseConnector
 from haystack_integrations.tracing.langfuse.tracer import (
-    _COMPONENT_OUTPUT_KEY, DefaultSpanHandler, LangfuseSpan, LangfuseTracer,
-    SpanContext)
+    _COMPONENT_OUTPUT_KEY,
+    DefaultSpanHandler,
+    LangfuseSpan,
+    LangfuseTracer,
+    SpanContext,
+)
+from haystack_integrations.components.connectors.langfuse import LangfuseConnector
 
 
 class MockSpan:
-    def __init__(self):
+    def __init__(self, name="mock_span"):
         self._data = {}
         self._span = self
-        self.operation_name = "operation_name"
+        self.operation_name = name
+        self._name = name
 
     def raw_span(self):
         return self
 
     def span(self, name=None):
-        # assert correct operation name passed to the span
-        assert name == "operation_name"
-        return self
+        # Return a new mock span for child spans
+        return MockSpan(name=name or "child_span")
 
     def update(self, **kwargs):
         self._data.update(kwargs)
 
     def generation(self, name=None):
-        return self
+        # Return a new mock span for generation spans
+        return MockSpan(name=name or "generation_span")
 
     def end(self):
         pass
 
 
 class MockTracer:
-
     def trace(self, name, **kwargs):
-        return MockSpan()
+        # Return a unique mock span for each trace call
+        return MockSpan(name=name)
 
     def flush(self):
         pass
@@ -62,7 +68,6 @@ class CustomSpanHandler(DefaultSpanHandler):
 
 
 class TestLangfuseSpan:
-
     #  LangfuseSpan can be initialized with a span object
     def test_initialized_with_span_object(self):
         mock_span = Mock()
@@ -235,7 +240,8 @@ class TestLangfuseTracer:
         langfuse_instance = Mock()
         tracer = LangfuseTracer(tracer=langfuse_instance, name="Haystack", public=True)
         assert tracer._tracer == langfuse_instance
-        assert tracer._context == []
+        # Check behavioral state instead of internal _context list
+        assert tracer.current_span() is None
         assert tracer._name == "Haystack"
         assert tracer._public
 
@@ -258,13 +264,14 @@ class TestLangfuseTracer:
 
             # check that the trace method is called on the tracer instance with the provided operation name and tags
             with tracer.trace("operation_name", tags={"tag1": "value1", "tag2": "value2"}) as span:
-                assert len(tracer._context) == 1, "The trace span should have been added to the the root context span"
+                # Check that there is a current active span during tracing
+                assert tracer.current_span() is not None, "There should be an active span during tracing"
+                assert tracer.current_span() == span, "The current span should be the active span"
                 assert span.raw_span().operation_name == "operation_name"
                 assert span.raw_span().metadata == {"tag1": "value1", "tag2": "value2"}
 
-            assert (
-                len(tracer._context) == 0
-            ), "The trace span should have been popped, and the root span is closed as well"
+            # Check that the span is cleaned up after tracing
+            assert tracer.current_span() is None, "There should be no active span after tracing completes"
 
     # 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):
@@ -327,12 +334,12 @@ class TestLangfuseTracer:
         assert mock_span.update.call_count >= 1
         name_update_call = None
         for call in mock_span.update.call_args_list:
-            if 'name' in call[1]:
+            if "name" in call[1]:
                 name_update_call = call
                 break
 
         assert name_update_call is not None, "No call to update the span name was made"
-        updated_name = name_update_call[1]['name']
+        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"
@@ -372,8 +379,7 @@ 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:
@@ -388,11 +394,12 @@ class TestLangfuseTracer:
         with tracer.trace(operation_name="operation_name", tags={"haystack.pipeline.input_data": "hello"}) as span:
             pass
 
-        assert tracer._context == []
+        # Check behavioral state instead of internal _context list
+        assert tracer.current_span() is None
 
     def test_init_with_tracing_disabled(self, monkeypatch, caplog):
         # Clear haystack modules because ProxyTracer is initialized whenever haystack is imported
-        modules_to_clear = [name for name in sys.modules if name.startswith('haystack')]
+        modules_to_clear = [name for name in sys.modules if name.startswith("haystack")]
         for name in modules_to_clear:
             sys.modules.pop(name, None)
 
@@ -403,58 +410,76 @@ class TestLangfuseTracer:
 
             LangfuseTracer(tracer=MockTracer(), name="Haystack", public=False)
             assert "tracing is disabled" in caplog.text
-
-    def test_context_cleanup_after_nested_failures(self):
+            
+    def test_async_concurrency_span_isolation(self):
         """
-        Test that tracer context is properly cleaned up even when nested operations fail.
+        Test that concurrent async traces maintain isolated span contexts.
 
-        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)
+        This test verifies that the context-local span stack prevents cross-request
+        span interleaving in concurrent environments like FastAPI servers.
         """
+        tracer = LangfuseTracer(tracer=MockTracer(), name="Haystack", public=False)
 
-
-        @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
+        # Track spans from each task for verification
+        task1_spans = []
+        task2_spans = []
+
+        async def trace_task(task_id: str, spans_list: list):
+            """Simulate a request with nested tracing operations"""
+            with tracer.trace(f"outer_operation_{task_id}") as outer_span:
+                spans_list.append(("outer", outer_span, tracer.current_span()))
+
+                # Simulate some async work
+                await asyncio.sleep(0.01)
+
+                with tracer.trace(f"inner_operation_{task_id}") as inner_span:
+                    spans_list.append(("inner", inner_span, tracer.current_span()))
+
+                    # Simulate more async work
+                    await asyncio.sleep(0.01)
+
+                    # Verify nested relationship within this task
+                    assert tracer.current_span() == inner_span
+
+                # After inner span, outer should be current again
+                spans_list.append(("after_inner", None, tracer.current_span()))
+                assert tracer.current_span() == outer_span
+
+            # After all spans, should be None
+            spans_list.append(("after_outer", None, tracer.current_span()))
+            assert tracer.current_span() is None
+
+        async def run_concurrent_traces():
+            """Run two concurrent tracing tasks"""
+            await asyncio.gather(trace_task("task1", task1_spans), trace_task("task2", task2_spans))
+
+        # Run the concurrent test
+        asyncio.run(run_concurrent_traces())
+
+        # Verify both tasks completed successfully
+        assert len(task1_spans) == 4
+        assert len(task2_spans) == 4
+
+        # Verify each task had proper span isolation
+        # Task 1 spans should be different from Task 2 spans
+        task1_outer = task1_spans[0][1]  # outer span from task1
+        task2_outer = task2_spans[0][1]  # outer span from task2
+        assert task1_outer != task2_outer
+
+        task1_inner = task1_spans[1][1]  # inner span from task1
+        task2_inner = task2_spans[1][1]  # inner span from task2
+        assert task1_inner != task2_inner
+
+        # Verify proper nesting within each task
+        # Task 1: outer -> inner -> outer -> None
+        assert task1_spans[0][2] == task1_outer  # current_span during outer
+        assert task1_spans[1][2] == task1_inner  # current_span during inner
+        assert task1_spans[2][2] == task1_outer  # current_span after inner
+        assert task1_spans[3][2] is None  # current_span after outer
+
+        # Task 2: outer -> inner -> outer -> None
+        assert task2_spans[0][2] == task2_outer  # current_span during outer
+        assert task2_spans[1][2] == task2_inner  # current_span during inner
+        assert task2_spans[2][2] == task2_outer  # current_span after inner
+        assert task2_spans[3][2] is None  # current_span after outer
+  

{langfuse_haystack-2.2.1 → langfuse_haystack-2.3.0}/tests/test_tracing.py

@@ -6,6 +6,7 @@ import os
 import time
 from typing import Any, Dict, List
 from urllib.parse import urlparse
+import json
 
 import pytest
 import requests
@@ -189,3 +190,67 @@ def test_tracing_with_sub_pipelines():
     component_names = [key for obs in haystack_pipeline_run_observations for key in obs["input"].keys()]
     assert "prompt_builder" in component_names
     assert "llm" in component_names
+
+@pytest.mark.skipif(
+    not all(
+        [
+            os.environ.get("LANGFUSE_SECRET_KEY"),
+            os.environ.get("LANGFUSE_PUBLIC_KEY"),
+        ]
+    ),
+    reason="Missing required environment variables: LANGFUSE_SECRET_KEY and LANGFUSE_PUBLIC_KEY",
+)
+@pytest.mark.integration
+def test_context_cleanup_after_nested_failures():
+    """
+    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    

langfuse_haystack-2.2.1/PKG-INFO

@@ -1,154 +0,0 @@
-Metadata-Version: 2.4
-Name: langfuse-haystack
-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
-Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/langfuse
-Author-email: deepset GmbH <info@deepset.ai>
-License-Expression: Apache-2.0
-License-File: LICENSE.txt
-Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-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<3.0.0,>=2.9.0
-Description-Content-Type: text/markdown
-
-# langfuse-haystack
-
-[![PyPI - Version](https://img.shields.io/pypi/v/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
-
-langfuse-haystack integrates tracing capabilities into [Haystack](https://github.com/deepset-ai/haystack) (2.x) pipelines using [Langfuse](https://langfuse.com/). 
-This package enhances the visibility of pipeline runs by capturing comprehensive details of the execution traces, including API calls, context data, prompts, and more. 
-Whether you're monitoring model performance, pinpointing areas for improvement, or creating datasets for fine-tuning and testing from your pipeline executions, langfuse-haystack is the right tool for you.
-
-## Features
-
-- Easy integration with Haystack pipelines
-- Capture the full context of the execution
-- Track model usage and cost
-- Collect user feedback
-- Identify low-quality outputs
-- Build fine-tuning and testing datasets
-
-## Installation
-
-To install langfuse-haystack, run the following command:
-
-```sh
-pip install langfuse-haystack
-```
-
-## Usage
-
-To enable tracing in your Haystack pipeline, add the `LangfuseConnector` to your pipeline.
-You also need to set the `LANGFUSE_SECRET_KEY` and `LANGFUSE_PUBLIC_KEY` environment variables in order to connect to Langfuse account.
-You can get these keys by signing up for an account on the Langfuse website.
-
-⚠️ **Important:** To ensure proper tracing, always set environment variables before importing any Haystack components. 
-This is crucial because Haystack initializes its internal tracing components during import.
-
-Here's the correct way to set up your script:
-
-```python
-import os
-
-# Set environment variables first
-os.environ["LANGFUSE_SECRET_KEY"] = ""  # Your Langfuse secret key
-os.environ["LANGFUSE_PUBLIC_KEY"] = ""  # Your Langfuse public key
-os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
-
-# Then import Haystack components
-from haystack.components.builders import ChatPromptBuilder
-from haystack.components.generators.chat import OpenAIChatGenerator
-from haystack.dataclasses import ChatMessage
-from haystack import Pipeline
-
-from haystack_integrations.components.connectors.langfuse import LangfuseConnector
-
-# Rest of your code...
-```
-
-Alternatively, an even better practice is to set these environment variables in your shell before running the script.
-
-
-Here's a full example:
-
-```python
-import os
-
-os.environ["LANGFUSE_SECRET_KEY"] = ""  # Your Langfuse secret key
-os.environ["LANGFUSE_PUBLIC_KEY"] = ""  # Your Langfuse public key
-os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
-
-from haystack.components.builders import ChatPromptBuilder
-from haystack.components.generators.chat import OpenAIChatGenerator
-from haystack.dataclasses import ChatMessage
-from haystack import Pipeline
-
-from haystack_integrations.components.connectors.langfuse import LangfuseConnector
-
-pipe = Pipeline()
-pipe.add_component("tracer", LangfuseConnector("Chat example"))
-pipe.add_component("prompt_builder", ChatPromptBuilder())
-pipe.add_component("llm", OpenAIChatGenerator(model="gpt-3.5-turbo"))
-
-pipe.connect("prompt_builder.prompt", "llm.messages")
-
-messages = [
-    ChatMessage.from_system("Always respond in German even if some input data is in other languages."),
-    ChatMessage.from_user("Tell me about {{location}}"),
-]
-
-response = pipe.run(
-    data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}}
-)
-print(response["llm"]["replies"][0])
-print(response["tracer"]["trace_url"])
-print(response["tracer"]["trace_id"])
-```
-
-In this example, we add the `LangfuseConnector` to the pipeline with the name "tracer". 
-Each run of the pipeline produces one trace viewable on the Langfuse website with a specific URL. 
-The trace captures the entire execution context, including the prompts, completions, and metadata.
-
-## Trace Visualization
-
-Langfuse provides a user-friendly interface to visualize and analyze the traces generated by your Haystack pipeline. 
-Login into your Langfuse account and navigate to the trace URL to view the trace details.
-
-## Contributing
-
-`hatch` is the best way to interact with this project. To install it, run:
-```sh
-pip install hatch
-```
-
-With `hatch` installed, run all the tests:
-```
-hatch run test:all
-```
-
-To format your code and perform linting using Ruff (with automatic fixes), run:
-```
-hatch run fmt
-```
-
-To check for static type errors, run:
-
-```console
-$ hatch run test:types
-```
-
-## License
-
-`langfuse-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

langfuse_haystack-2.2.1/README.md

@@ -1,130 +0,0 @@
-# langfuse-haystack
-
-[![PyPI - Version](https://img.shields.io/pypi/v/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/langfuse-haystack.svg)](https://pypi.org/project/langfuse-haystack)
-
-langfuse-haystack integrates tracing capabilities into [Haystack](https://github.com/deepset-ai/haystack) (2.x) pipelines using [Langfuse](https://langfuse.com/). 
-This package enhances the visibility of pipeline runs by capturing comprehensive details of the execution traces, including API calls, context data, prompts, and more. 
-Whether you're monitoring model performance, pinpointing areas for improvement, or creating datasets for fine-tuning and testing from your pipeline executions, langfuse-haystack is the right tool for you.
-
-## Features
-
-- Easy integration with Haystack pipelines
-- Capture the full context of the execution
-- Track model usage and cost
-- Collect user feedback
-- Identify low-quality outputs
-- Build fine-tuning and testing datasets
-
-## Installation
-
-To install langfuse-haystack, run the following command:
-
-```sh
-pip install langfuse-haystack
-```
-
-## Usage
-
-To enable tracing in your Haystack pipeline, add the `LangfuseConnector` to your pipeline.
-You also need to set the `LANGFUSE_SECRET_KEY` and `LANGFUSE_PUBLIC_KEY` environment variables in order to connect to Langfuse account.
-You can get these keys by signing up for an account on the Langfuse website.
-
-⚠️ **Important:** To ensure proper tracing, always set environment variables before importing any Haystack components. 
-This is crucial because Haystack initializes its internal tracing components during import.
-
-Here's the correct way to set up your script:
-
-```python
-import os
-
-# Set environment variables first
-os.environ["LANGFUSE_SECRET_KEY"] = ""  # Your Langfuse secret key
-os.environ["LANGFUSE_PUBLIC_KEY"] = ""  # Your Langfuse public key
-os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
-
-# Then import Haystack components
-from haystack.components.builders import ChatPromptBuilder
-from haystack.components.generators.chat import OpenAIChatGenerator
-from haystack.dataclasses import ChatMessage
-from haystack import Pipeline
-
-from haystack_integrations.components.connectors.langfuse import LangfuseConnector
-
-# Rest of your code...
-```
-
-Alternatively, an even better practice is to set these environment variables in your shell before running the script.
-
-
-Here's a full example:
-
-```python
-import os
-
-os.environ["LANGFUSE_SECRET_KEY"] = ""  # Your Langfuse secret key
-os.environ["LANGFUSE_PUBLIC_KEY"] = ""  # Your Langfuse public key
-os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
-
-from haystack.components.builders import ChatPromptBuilder
-from haystack.components.generators.chat import OpenAIChatGenerator
-from haystack.dataclasses import ChatMessage
-from haystack import Pipeline
-
-from haystack_integrations.components.connectors.langfuse import LangfuseConnector
-
-pipe = Pipeline()
-pipe.add_component("tracer", LangfuseConnector("Chat example"))
-pipe.add_component("prompt_builder", ChatPromptBuilder())
-pipe.add_component("llm", OpenAIChatGenerator(model="gpt-3.5-turbo"))
-
-pipe.connect("prompt_builder.prompt", "llm.messages")
-
-messages = [
-    ChatMessage.from_system("Always respond in German even if some input data is in other languages."),
-    ChatMessage.from_user("Tell me about {{location}}"),
-]
-
-response = pipe.run(
-    data={"prompt_builder": {"template_variables": {"location": "Berlin"}, "template": messages}}
-)
-print(response["llm"]["replies"][0])
-print(response["tracer"]["trace_url"])
-print(response["tracer"]["trace_id"])
-```
-
-In this example, we add the `LangfuseConnector` to the pipeline with the name "tracer". 
-Each run of the pipeline produces one trace viewable on the Langfuse website with a specific URL. 
-The trace captures the entire execution context, including the prompts, completions, and metadata.
-
-## Trace Visualization
-
-Langfuse provides a user-friendly interface to visualize and analyze the traces generated by your Haystack pipeline. 
-Login into your Langfuse account and navigate to the trace URL to view the trace details.
-
-## Contributing
-
-`hatch` is the best way to interact with this project. To install it, run:
-```sh
-pip install hatch
-```
-
-With `hatch` installed, run all the tests:
-```
-hatch run test:all
-```
-
-To format your code and perform linting using Ruff (with automatic fixes), run:
-```
-hatch run fmt
-```
-
-To check for static type errors, run:
-
-```console
-$ hatch run test:types
-```
-
-## License
-
-`langfuse-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.