turingpulse-sdk-haystack 1.0.0__tar.gz

turingpulse_sdk_haystack-1.0.0/.gitignore

@@ -0,0 +1,42 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Database files
+*.db
+*.sqlite3
+
+# Environment variables
+.env
+.env.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Logs
+*.log
+logs/
+
+# OS files
+.DS_Store
+Thumbs.db

turingpulse_sdk_haystack-1.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: turingpulse-sdk-haystack
+Version: 1.0.0
+Summary: TuringPulse SDK integration for Haystack
+License-Expression: Apache-2.0
+Requires-Python: >=3.11
+Requires-Dist: haystack-ai>=2.24.1
+Requires-Dist: turingpulse-sdk>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'

turingpulse_sdk_haystack-1.0.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "turingpulse-sdk-haystack"
+version = "1.0.0"
+description = "TuringPulse SDK integration for Haystack"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+dependencies = [
+    "turingpulse-sdk>=1.0.0",
+    "haystack-ai>=2.24.1",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23"]

turingpulse_sdk_haystack-1.0.0/turingpulse_sdk_haystack/__init__.py

@@ -0,0 +1,6 @@
+"""TuringPulse SDK integration for Haystack."""
+
+from ._wrapper import instrument_haystack
+
+__version__ = "0.1.0"
+__all__ = ["instrument_haystack"]

turingpulse_sdk_haystack-1.0.0/turingpulse_sdk_haystack/_wrapper.py

@@ -0,0 +1,149 @@
+"""Haystack instrumentation for TuringPulse.
+
+Wraps ``Pipeline.run()`` to capture component executions,
+model calls, retriever operations, and pipeline structure.
+"""
+
+from __future__ import annotations
+
+import logging
+from contextvars import ContextVar
+from typing import Any, Dict, Optional, Sequence
+
+from turingpulse_sdk import instrument, GovernanceDirective
+from turingpulse_sdk.config import MAX_FIELD_SIZE
+from turingpulse_sdk.context import current_context
+from turingpulse_sdk.integrations.base import emit_child_spans
+
+logger = logging.getLogger("turingpulse.sdk.haystack")
+
+_INSTRUMENTING: ContextVar[bool] = ContextVar("_tp_haystack_instrumenting", default=False)
+
+
+def instrument_haystack(
+    pipeline,
+    *,
+    name: str,
+    governance: Optional[GovernanceDirective] = None,
+    model: Optional[str] = None,
+    provider: str = "openai",
+    kpis: Optional[Sequence["KPIConfig"]] = None,
+    metadata: Optional[Dict[str, str]] = None,
+):
+    """Wrap a Haystack Pipeline for TuringPulse observability.
+
+    Returns a callable wrapping ``pipeline.run()``.
+
+    Args:
+        pipeline: A ``haystack.Pipeline`` instance.
+        name: Workflow display name.
+        governance: Optional governance directive.
+        model: LLM model name override.
+        provider: LLM provider name.
+
+    Returns:
+        A callable wrapping the pipeline's run method.
+    """
+
+    @instrument(name=name, governance=governance, kpis=kpis, metadata=metadata or {})
+    def _run(data: Dict[str, Any], **kwargs: Any) -> Dict[str, Any]:
+        token = _INSTRUMENTING.set(True)
+        try:
+            result = pipeline.run(data, **kwargs)
+
+            ctx = current_context()
+            if ctx:
+                ctx.framework = "haystack"
+                ctx.node_type = "workflow"
+
+                ctx.set_io(
+                    input_data=str(data)[:MAX_FIELD_SIZE],
+                    output_data=str(result)[:MAX_FIELD_SIZE],
+                )
+
+                if model:
+                    ctx.set_model(model, provider)
+
+                total_prompt, total_completion = _extract_pipeline_tokens(result)
+                if total_prompt or total_completion:
+                    ctx.set_tokens(total_prompt, total_completion)
+
+                spans = _build_component_spans(pipeline, result)
+                if spans:
+                    emit_child_spans(
+                        spans,
+                        run_id=ctx.run_id,
+                        parent_span_id=ctx.span_id,
+                        workflow_name=name,
+                        framework="haystack",
+                    )
+
+            return result
+        finally:
+            _INSTRUMENTING.reset(token)
+
+    return _run
+
+
+def _extract_pipeline_tokens(result: Dict[str, Any]) -> tuple:
+    """Walk component outputs looking for token usage metadata.
+
+    Haystack generators embed usage in each reply's ``.meta`` dict,
+    e.g. ``result["llm"]["replies"][i].meta["usage"]``.
+    """
+    total_prompt = 0
+    total_completion = 0
+    if not isinstance(result, dict):
+        return 0, 0
+    for output in result.values():
+        if not isinstance(output, dict):
+            continue
+        for val in output.values():
+            items = val if isinstance(val, list) else [val]
+            for item in items:
+                meta = getattr(item, "meta", None)
+                if not isinstance(meta, dict):
+                    if isinstance(item, dict):
+                        meta = item.get("meta")
+                    if not isinstance(meta, dict):
+                        continue
+                usage = meta.get("usage", {})
+                if isinstance(usage, dict):
+                    total_prompt += usage.get("prompt_tokens", 0) or 0
+                    total_completion += usage.get("completion_tokens", 0) or 0
+    return total_prompt, total_completion
+
+
+def _build_component_spans(pipeline, result: Dict[str, Any]) -> list:
+    """Extract per-component spans from the pipeline result."""
+    spans = []
+    if not isinstance(result, dict):
+        return spans
+
+    graph = getattr(pipeline, "graph", None)
+    if graph is None:
+        return spans
+
+    for component_name in graph.nodes:
+        if component_name in result:
+            component_output = result[component_name]
+            component = graph.nodes[component_name].get("instance")
+            node_type = "function"
+            if component:
+                cls_name = type(component).__name__.lower()
+                if "llm" in cls_name or "generator" in cls_name or "chatgenerator" in cls_name:
+                    node_type = "llm"
+                elif "retriever" in cls_name:
+                    node_type = "retriever"
+                elif "embedder" in cls_name:
+                    node_type = "embedder"
+
+            spans.append({
+                "node": component_name,
+                "node_type": node_type,
+                "status": "success",
+                "duration_ms": 0,
+                "output": str(component_output)[:MAX_FIELD_SIZE],
+            })
+
+    return spans