langfuse-haystack 0.6.3__tar.gz → 0.7.0__tar.gz

{langfuse_haystack-0.6.3 → langfuse_haystack-0.7.0}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [integrations/langfuse-v0.6.4] - 2025-01-17
+
+### 🚀 Features
+
+- Add LangfuseConnector secure key management and serialization  (#1287)
+
+
+## [integrations/langfuse-v0.6.3] - 2025-01-15
+
+### 🌀 Miscellaneous
+
+- Chore: Langfuse - pin `haystack-ai>=2.9.0` and simplify message conversion (#1292)
+
 ## [integrations/langfuse-v0.6.2] - 2025-01-02
 
 ### 🚀 Features

{langfuse_haystack-0.6.3 → langfuse_haystack-0.7.0}/PKG-INFO

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

{langfuse_haystack-0.6.3 → langfuse_haystack-0.7.0}/pyproject.toml

@@ -67,7 +67,12 @@ python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
 [tool.hatch.envs.lint]
 installer = "uv"
 detached = true
-dependencies = ["pip", "black>=23.1.0", "mypy>=1.0.0", "ruff>=0.0.243"]
+dependencies = [
+    "pip",
+    "black>=23.1.0",
+    "mypy>=1.0.0",
+    "ruff>=0.0.243",
+]
 
 [tool.hatch.envs.lint.scripts]
 typing = "mypy --install-types --non-interactive --explicit-package-bases {args:src/ tests}"
@@ -167,6 +172,7 @@ module = [
   "haystack_integrations.*",
   "pytest.*",
   "numpy.*",
+  "httpx.*",
 ]
 ignore_missing_imports = true
 

{langfuse_haystack-0.6.3 → langfuse_haystack-0.7.0}/src/haystack_integrations/components/connectors/langfuse/langfuse_connector.py

@@ -1,6 +1,8 @@
 from typing import Any, Dict, Optional
 
-from haystack import component, logging, tracing
+import httpx
+from haystack import component, default_from_dict, default_to_dict, logging, tracing
+from haystack.utils import Secret, deserialize_secrets_inplace
 
 from haystack_integrations.tracing.langfuse import LangfuseTracer
 from langfuse import Langfuse
@@ -94,7 +96,14 @@ class LangfuseConnector:
 
     """
 
-    def __init__(self, name: str, public: bool = False):
+    def __init__(
+        self,
+        name: str,
+        public: bool = False,
+        public_key: Optional[Secret] = Secret.from_env_var("LANGFUSE_PUBLIC_KEY"),  # noqa: B008
+        secret_key: Optional[Secret] = Secret.from_env_var("LANGFUSE_SECRET_KEY"),  # noqa: B008
+        httpx_client: Optional[httpx.Client] = None,
+    ):
         """
         Initialize the LangfuseConnector component.
 
@@ -103,9 +112,25 @@ class LangfuseConnector:
         :param public: Whether the tracing data should be public or private. If set to `True`, the tracing data will be
             publicly accessible to anyone with the tracing URL. If set to `False`, the tracing data will be private and
             only accessible to the Langfuse account owner. The default is `False`.
+        :param public_key: The Langfuse public key. Defaults to reading from LANGFUSE_PUBLIC_KEY environment variable.
+        :param secret_key: The Langfuse secret key. Defaults to reading from LANGFUSE_SECRET_KEY environment variable.
+        :param httpx_client: Optional custom httpx.Client instance to use for Langfuse API calls. Note that when
+            deserializing a pipeline from YAML, any custom client is discarded and Langfuse will create its own default
+            client, since HTTPX clients cannot be serialized.
         """
         self.name = name
-        self.tracer = LangfuseTracer(tracer=Langfuse(), name=name, public=public)
+        self.public = public
+        self.secret_key = secret_key
+        self.public_key = public_key
+        self.tracer = LangfuseTracer(
+            tracer=Langfuse(
+                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,
+            ),
+            name=name,
+            public=public,
+        )
         tracing.enable_tracing(self.tracer)
 
     @component.output_types(name=str, trace_url=str)
@@ -126,3 +151,29 @@ class LangfuseConnector:
             invocation_context=invocation_context,
         )
         return {"name": self.name, "trace_url": self.tracer.get_trace_url()}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serialize this component to a dictionary.
+
+        :returns: The serialized component as a dictionary.
+        """
+        return default_to_dict(
+            self,
+            name=self.name,
+            public=self.public,
+            secret_key=self.secret_key.to_dict() if self.secret_key else None,
+            public_key=self.public_key.to_dict() if self.public_key else None,
+            # Note: httpx_client is not serialized as it's not serializable
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "LangfuseConnector":
+        """
+        Deserialize this component from a dictionary.
+
+        :param data: The dictionary representation of this component.
+        :returns: The deserialized component instance.
+        """
+        deserialize_secrets_inplace(data["init_parameters"], keys=["secret_key", "public_key"])
+        return default_from_dict(cls, data)

{langfuse_haystack-0.6.3 → langfuse_haystack-0.7.0}/src/haystack_integrations/tracing/langfuse/tracer.py

@@ -201,7 +201,11 @@ class LangfuseTracer(Tracer):
                 )
 
         raw_span = span.raw_span()
-        if isinstance(raw_span, langfuse.client.StatefulSpanClient):
+
+        # 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, as its lifecycle is managed differently.
+        if isinstance(raw_span, (langfuse.client.StatefulSpanClient, langfuse.client.StatefulGenerationClient)):
             raw_span.end()
         self._context.pop()
 

langfuse_haystack-0.7.0/tests/test_tracing.py

@@ -0,0 +1,171 @@
+import os
+import time
+from urllib.parse import urlparse
+
+import pytest
+import requests
+from haystack import Pipeline
+from haystack.components.builders import ChatPromptBuilder
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.dataclasses import ChatMessage
+from haystack.utils import Secret
+from requests.auth import HTTPBasicAuth
+import httpx
+
+from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator
+from haystack_integrations.components.generators.cohere import CohereChatGenerator
+
+# don't remove (or move) this env var setting from here, it's needed to turn tracing on
+os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
+
+
+@pytest.fixture
+def pipeline_with_env_vars(llm_class, expected_trace):
+    """Pipeline factory using environment variables for Langfuse authentication"""
+    pipe = Pipeline()
+    pipe.add_component("tracer", LangfuseConnector(name=f"Chat example - {expected_trace}", public=True))
+    pipe.add_component("prompt_builder", ChatPromptBuilder())
+    pipe.add_component("llm", llm_class())
+    pipe.connect("prompt_builder.prompt", "llm.messages")
+    return pipe
+
+
+@pytest.fixture
+def pipeline_with_secrets(llm_class, expected_trace):
+    """Pipeline factory using Secret objects for Langfuse authentication"""
+    pipe = Pipeline()
+    pipe.add_component(
+        "tracer",
+        LangfuseConnector(
+            name=f"Chat example - {expected_trace}",
+            public=True,
+            secret_key=Secret.from_env_var("LANGFUSE_SECRET_KEY"),
+            public_key=Secret.from_env_var("LANGFUSE_PUBLIC_KEY"),
+        ),
+    )
+    pipe.add_component("prompt_builder", ChatPromptBuilder())
+    pipe.add_component("llm", llm_class())
+    pipe.connect("prompt_builder.prompt", "llm.messages")
+    return pipe
+
+
+@pytest.fixture
+def pipeline_with_custom_client(llm_class, expected_trace):
+    """Pipeline factory using custom httpx client for Langfuse"""
+    pipe = Pipeline()
+    custom_client = httpx.Client(timeout=30.0)  # Custom timeout of 30 seconds
+    pipe.add_component(
+        "tracer",
+        LangfuseConnector(
+            name=f"Chat example - {expected_trace}",
+            public=True,
+            secret_key=Secret.from_env_var("LANGFUSE_SECRET_KEY"),
+            public_key=Secret.from_env_var("LANGFUSE_PUBLIC_KEY"),
+            httpx_client=custom_client,
+        ),
+    )
+    pipe.add_component("prompt_builder", ChatPromptBuilder())
+    pipe.add_component("llm", llm_class())
+    pipe.connect("prompt_builder.prompt", "llm.messages")
+    return pipe
+
+
+@pytest.mark.integration
+@pytest.mark.parametrize(
+    "llm_class, env_var, expected_trace",
+    [
+        (OpenAIChatGenerator, "OPENAI_API_KEY", "OpenAI"),
+        (AnthropicChatGenerator, "ANTHROPIC_API_KEY", "Anthropic"),
+        (CohereChatGenerator, "COHERE_API_KEY", "Cohere"),
+    ],
+)
+@pytest.mark.parametrize(
+    "pipeline_fixture", ["pipeline_with_env_vars", "pipeline_with_secrets", "pipeline_with_custom_client"]
+)
+def test_tracing_integration(llm_class, env_var, expected_trace, pipeline_fixture, request):
+    if not all([os.environ.get("LANGFUSE_SECRET_KEY"), os.environ.get("LANGFUSE_PUBLIC_KEY"), os.environ.get(env_var)]):
+        pytest.skip(f"Missing required environment variables: LANGFUSE_SECRET_KEY, LANGFUSE_PUBLIC_KEY, or {env_var}")
+
+    pipe = request.getfixturevalue(pipeline_fixture)
+    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},
+            "tracer": {"invocation_context": {"user_id": "user_42"}},
+        }
+    )
+    assert "Berlin" in response["llm"]["replies"][0].text
+    assert response["tracer"]["trace_url"]
+
+    trace_url = response["tracer"]["trace_url"]
+    uuid = os.path.basename(urlparse(trace_url).path)
+    url = f"https://cloud.langfuse.com/api/public/traces/{uuid}"
+
+    # Poll the Langfuse API a bit as the trace might not be ready right away
+    attempts = 5
+    delay = 1
+    while attempts >= 0:
+        res = requests.get(
+            url, auth=HTTPBasicAuth(os.environ["LANGFUSE_PUBLIC_KEY"], os.environ["LANGFUSE_SECRET_KEY"])
+        )
+        if attempts > 0 and res.status_code != 200:
+            attempts -= 1
+            time.sleep(delay)
+            delay *= 2
+            continue
+        assert res.status_code == 200, f"Failed to retrieve data from Langfuse API: {res.status_code}"
+
+        # check if the trace contains the expected LLM name
+        assert expected_trace in str(res.content)
+        # check if the trace contains the expected generation span
+        assert "GENERATION" in str(res.content)
+        # check if the trace contains the expected user_id
+        assert "user_42" in str(res.content)
+        break
+
+
+def test_pipeline_serialization(monkeypatch):
+    """Test that a pipeline with secrets can be properly serialized and deserialized"""
+
+    # 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
+    pipe = Pipeline()
+    pipe.add_component(
+        "tracer",
+        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"),
+        ),
+    )
+    pipe.add_component("prompt_builder", ChatPromptBuilder())
+    pipe.add_component("llm", OpenAIChatGenerator())
+    pipe.connect("prompt_builder.prompt", "llm.messages")
+
+    # Serialize
+    serialized = pipe.to_dict()
+
+    # Check serialized secrets
+    tracer_params = serialized["components"]["tracer"]["init_parameters"]
+    assert isinstance(tracer_params["secret_key"], dict)
+    assert tracer_params["secret_key"]["type"] == "env_var"
+    assert tracer_params["secret_key"]["env_vars"] == ["LANGFUSE_SECRET_KEY"]
+    assert isinstance(tracer_params["public_key"], dict)
+    assert tracer_params["public_key"]["type"] == "env_var"
+    assert tracer_params["public_key"]["env_vars"] == ["LANGFUSE_PUBLIC_KEY"]
+
+    # Deserialize
+    new_pipe = Pipeline.from_dict(serialized)
+
+    # Verify pipeline is the same
+    assert new_pipe == pipe

langfuse_haystack-0.6.3/tests/test_tracing.py

@@ -1,79 +0,0 @@
-import os
-import random
-import time
-from urllib.parse import urlparse
-
-import pytest
-import requests
-from haystack import Pipeline
-from haystack.components.builders import ChatPromptBuilder
-from haystack.components.generators.chat import OpenAIChatGenerator
-from haystack.dataclasses import ChatMessage
-from requests.auth import HTTPBasicAuth
-
-from haystack_integrations.components.connectors.langfuse import LangfuseConnector
-from haystack_integrations.components.generators.anthropic import AnthropicChatGenerator
-from haystack_integrations.components.generators.cohere import CohereChatGenerator
-
-# don't remove (or move) this env var setting from here, it's needed to turn tracing on
-os.environ["HAYSTACK_CONTENT_TRACING_ENABLED"] = "true"
-
-
-@pytest.mark.integration
-@pytest.mark.parametrize(
-    "llm_class, env_var, expected_trace",
-    [
-        (OpenAIChatGenerator, "OPENAI_API_KEY", "OpenAI"),
-        (AnthropicChatGenerator, "ANTHROPIC_API_KEY", "Anthropic"),
-        (CohereChatGenerator, "COHERE_API_KEY", "Cohere"),
-    ],
-)
-def test_tracing_integration(llm_class, env_var, expected_trace):
-    if not all([os.environ.get("LANGFUSE_SECRET_KEY"), os.environ.get("LANGFUSE_PUBLIC_KEY"), os.environ.get(env_var)]):
-        pytest.skip(f"Missing required environment variables: LANGFUSE_SECRET_KEY, LANGFUSE_PUBLIC_KEY, or {env_var}")
-
-    pipe = Pipeline()
-    pipe.add_component("tracer", LangfuseConnector(name=f"Chat example - {expected_trace}", public=True))
-    pipe.add_component("prompt_builder", ChatPromptBuilder())
-    pipe.add_component("llm", llm_class())
-    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},
-            "tracer": {"invocation_context": {"user_id": "user_42"}},
-        }
-    )
-    assert "Berlin" in response["llm"]["replies"][0].text
-    assert response["tracer"]["trace_url"]
-
-    trace_url = response["tracer"]["trace_url"]
-    uuid = os.path.basename(urlparse(trace_url).path)
-    url = f"https://cloud.langfuse.com/api/public/traces/{uuid}"
-
-    # Poll the Langfuse API a bit as the trace might not be ready right away
-    attempts = 5
-    delay = 1
-    while attempts >= 0:
-        res = requests.get(
-            url, auth=HTTPBasicAuth(os.environ["LANGFUSE_PUBLIC_KEY"], os.environ["LANGFUSE_SECRET_KEY"])
-        )
-        if attempts > 0 and res.status_code != 200:
-            attempts -= 1
-            time.sleep(delay)
-            delay *= 2
-            continue
-        assert res.status_code == 200, f"Failed to retrieve data from Langfuse API: {res.status_code}"
-
-        # check if the trace contains the expected LLM name
-        assert expected_trace in str(res.content)
-        # check if the trace contains the expected generation span
-        assert "GENERATION" in str(res.content)
-        # check if the trace contains the expected user_id
-        assert "user_42" in str(res.content)
-        break