mseep-agentops 0.4.18__py3-none-any.whl → 0.4.23__py3-none-any.whl

agentops/instrumentation/agentic/haystack/__init__.py

@@ -0,0 +1 @@
+from .instrumentor import HaystackInstrumentor  # noqa: F401

agentops/instrumentation/agentic/haystack/instrumentor.py

@@ -0,0 +1,186 @@
+from typing import Any, Dict
+from opentelemetry.trace import SpanKind
+from opentelemetry.instrumentation.utils import unwrap
+from wrapt import wrap_function_wrapper
+
+from agentops.instrumentation.common import (
+    CommonInstrumentor,
+    InstrumentorConfig,
+    StandardMetrics,
+    create_wrapper_factory,
+    create_span,
+    SpanAttributeManager,
+)
+from agentops.semconv import SpanAttributes
+
+
+_instruments = ("haystack-ai >= 2.0.0",)
+
+
+class HaystackInstrumentor(CommonInstrumentor):
+    def __init__(self):
+        config = InstrumentorConfig(
+            library_name="haystack",
+            library_version="2",
+            wrapped_methods=[],
+            metrics_enabled=False,
+            dependencies=_instruments,
+        )
+        super().__init__(config)
+        self._attribute_manager = None
+
+    def _initialize(self, **kwargs):
+        application_name = kwargs.get("application_name", "default_application")
+        environment = kwargs.get("environment", "default_environment")
+        self._attribute_manager = SpanAttributeManager(
+            service_name=application_name, deployment_environment=environment
+        )
+
+    def _create_metrics(self, meter) -> Dict[str, Any]:
+        return StandardMetrics.create_standard_metrics(meter)
+
+    def _custom_wrap(self, **kwargs):
+        attr_manager = self._attribute_manager
+
+        wrap_function_wrapper(
+            "haystack.components.generators.openai",
+            "OpenAIGenerator.run",
+            create_wrapper_factory(_wrap_haystack_run_impl, self._metrics, attr_manager)(self._tracer),
+        )
+
+        wrap_function_wrapper(
+            "haystack.components.generators.chat",
+            "AzureOpenAIChatGenerator.run",
+            create_wrapper_factory(_wrap_haystack_run_impl, self._metrics, attr_manager)(self._tracer),
+        )
+
+        try:
+            wrap_function_wrapper(
+                "haystack.components.generators.openai",
+                "OpenAIGenerator.stream",
+                create_wrapper_factory(_wrap_haystack_stream_impl, self._metrics, attr_manager)(self._tracer),
+            )
+        except Exception:
+            pass
+
+        try:
+            wrap_function_wrapper(
+                "haystack.components.generators.chat",
+                "AzureOpenAIChatGenerator.stream",
+                create_wrapper_factory(_wrap_haystack_stream_impl, self._metrics, attr_manager)(self._tracer),
+            )
+        except Exception:
+            pass
+
+    def _custom_unwrap(self, **kwargs):
+        unwrap("haystack.components.generators.openai", "OpenAIGenerator.run")
+        unwrap("haystack.components.generators.chat", "AzureOpenAIChatGenerator.run")
+        try:
+            unwrap("haystack.components.generators.openai", "OpenAIGenerator.stream")
+        except Exception:
+            pass
+        try:
+            unwrap("haystack.components.generators.chat", "AzureOpenAIChatGenerator.stream")
+        except Exception:
+            pass
+
+
+def _first_non_empty_text(value):
+    if isinstance(value, list) and value:
+        return _first_non_empty_text(value[0])
+    if isinstance(value, dict):
+        if "content" in value:
+            return str(value["content"])
+        if "text" in value:
+            return str(value["text"])
+        if "replies" in value and value["replies"]:
+            return str(value["replies"][0])
+    if value is None:
+        return None
+    return str(value)
+
+
+def _extract_prompt(args, kwargs):
+    if "prompt" in kwargs:
+        return kwargs.get("prompt")
+    if "messages" in kwargs:
+        return kwargs.get("messages")
+    if args:
+        return args[0]
+    return None
+
+
+def _get_model_name(instance):
+    for attr in ("model", "model_name", "deployment_name", "deployment"):
+        if hasattr(instance, attr):
+            val = getattr(instance, attr)
+            if val:
+                return str(val)
+    return None
+
+
+def _wrap_haystack_run_impl(tracer, metrics, attr_manager, wrapped, instance, args, kwargs):
+    model = _get_model_name(instance)
+    with create_span(
+        tracer,
+        "haystack.generator.run",
+        kind=SpanKind.CLIENT,
+        attributes={
+            SpanAttributes.LLM_SYSTEM: "haystack",
+            "gen_ai.model": model,
+            SpanAttributes.LLM_REQUEST_STREAMING: False,
+        },
+        attribute_manager=attr_manager,
+    ) as span:
+        prompt = _extract_prompt(args, kwargs)
+        prompt_text = _first_non_empty_text(prompt)
+        if prompt_text:
+            span.set_attribute("gen_ai.prompt.0.content", prompt_text[:500])
+
+        result = wrapped(*args, **kwargs)
+
+        reply_text = None
+        if isinstance(result, dict):
+            reply_text = _first_non_empty_text(result.get("replies"))
+            if not reply_text:
+                reply_text = _first_non_empty_text(result)
+        else:
+            reply_text = _first_non_empty_text(result)
+
+        if reply_text:
+            span.set_attribute("gen_ai.response.0.content", str(reply_text)[:500])
+
+        return result
+
+
+def _wrap_haystack_stream_impl(tracer, metrics, attr_manager, wrapped, instance, args, kwargs):
+    model = _get_model_name(instance)
+    with create_span(
+        tracer,
+        "haystack.generator.stream",
+        kind=SpanKind.CLIENT,
+        attributes={
+            SpanAttributes.LLM_SYSTEM: "haystack",
+            "gen_ai.model": model,
+            SpanAttributes.LLM_REQUEST_STREAMING: True,
+        },
+        attribute_manager=attr_manager,
+    ) as span:
+        prompt = _extract_prompt(args, kwargs)
+        prompt_text = _first_non_empty_text(prompt)
+        if prompt_text:
+            span.set_attribute("gen_ai.prompt.0.content", prompt_text[:500])
+
+        out = wrapped(*args, **kwargs)
+
+        try:
+            chunk_count = 0
+            for chunk in out:
+                chunk_count += 1
+                last_text = _first_non_empty_text(chunk)
+                if last_text:
+                    span.set_attribute("gen_ai.response.0.content", str(last_text)[:500])
+                yield chunk
+            span.set_attribute("gen_ai.response.chunk_count", chunk_count)
+        except TypeError:
+            return out

agentops/instrumentation/agentic/langgraph/__init__.py

@@ -0,0 +1,3 @@
+from agentops.instrumentation.agentic.langgraph.instrumentation import LanggraphInstrumentor
+
+__all__ = ["LanggraphInstrumentor"]

agentops/instrumentation/agentic/langgraph/attributes.py

@@ -0,0 +1,54 @@
+from typing import Dict, Any
+import json
+
+
+def ensure_no_none_values(attributes: Dict[str, Any]) -> Dict[str, Any]:
+    return {k: v for k, v in attributes.items() if v is not None}
+
+
+def set_graph_attributes(span: Any, graph_nodes: list = None, graph_edges: list = None) -> None:
+    if graph_nodes:
+        span.set_attribute("langgraph.graph.nodes", json.dumps(graph_nodes))
+        span.set_attribute("langgraph.graph.node_count", len(graph_nodes))
+
+        for i, node in enumerate(graph_nodes):
+            span.set_attribute(f"langgraph.node.{i}.name", node)
+            span.set_attribute(f"langgraph.node.{i}.type", "unknown")
+
+    if graph_edges:
+        span.set_attribute("langgraph.graph.edges", json.dumps(graph_edges))
+        span.set_attribute("langgraph.graph.edge_count", len(graph_edges))
+
+        for i, edge in enumerate(graph_edges):
+            parts = edge.split("->")
+            if len(parts) == 2:
+                span.set_attribute(f"langgraph.edge.{i}.source", parts[0])
+                span.set_attribute(f"langgraph.edge.{i}.target", parts[1])
+
+
+def extract_messages_from_input(input_data: Any) -> list:
+    if isinstance(input_data, dict) and "messages" in input_data:
+        return input_data["messages"]
+    return []
+
+
+def extract_messages_from_output(output_data: Any) -> list:
+    if isinstance(output_data, dict) and "messages" in output_data:
+        return output_data["messages"]
+    return []
+
+
+def get_message_content(message: Any) -> str:
+    if hasattr(message, "content"):
+        return str(message.content)
+    return ""
+
+
+def get_message_role(message: Any) -> str:
+    if hasattr(message, "role"):
+        return message.role
+    elif hasattr(message, "type"):
+        return message.type
+    elif hasattr(message, "__class__"):
+        return message.__class__.__name__.replace("Message", "").lower()
+    return "unknown"