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

agentops/instrumentation/providers/anthropic/attributes/tools.py

@@ -0,0 +1,231 @@
+"""Tool-related attribute extraction for Anthropic API."""
+
+import json
+from typing import Dict, Any, List, Optional
+
+from agentops.logging import logger
+from agentops.semconv import SpanAttributes, MessageAttributes, ToolAttributes, ToolStatus
+from agentops.instrumentation.common.attributes import AttributeMap
+
+
+def extract_tool_definitions(tools: List[Dict[str, Any]]) -> AttributeMap:
+    """Extract attributes from tool definitions.
+
+    Processes a list of Anthropic tool definitions and converts them into
+    standardized attributes for OpenTelemetry instrumentation. This captures
+    information about each tool's name, description, and input schema.
+
+    Args:
+        tools: List of tool definition objects
+
+    Returns:
+        Dictionary of tool-related attributes
+    """
+    attributes = {}
+
+    try:
+        if not tools:
+            return attributes
+
+        for i, tool in enumerate(tools):
+            name = tool.get("name", "unknown")
+            description = tool.get("description", "")
+
+            attributes[MessageAttributes.TOOL_CALL_NAME.format(i=i)] = name
+            attributes[MessageAttributes.TOOL_CALL_TYPE.format(i=i)] = "function"
+
+            if description:
+                attributes[MessageAttributes.TOOL_CALL_DESCRIPTION.format(i=i)] = description
+
+            if "input_schema" in tool:
+                attributes[MessageAttributes.TOOL_CALL_ARGUMENTS.format(i=i)] = json.dumps(tool["input_schema"])
+
+            tool_id = tool.get("id", f"tool-{i}")
+            attributes[MessageAttributes.TOOL_CALL_ID.format(i=i)] = tool_id
+            attributes[MessageAttributes.TOOL_CALL_NAME.format(i=i)] = name
+            if description:
+                attributes[MessageAttributes.TOOL_CALL_DESCRIPTION.format(i=i)] = description
+
+        tool_names = [tool.get("name", "unknown") for tool in tools]
+        attributes[SpanAttributes.LLM_REQUEST_FUNCTIONS] = json.dumps(tool_names)
+
+        tool_schemas = []
+        for tool in tools:
+            schema = {"name": tool.get("name", "unknown"), "schema": {}}
+
+            if "description" in tool:
+                schema["schema"]["description"] = tool["description"]
+            if "input_schema" in tool:
+                schema["schema"]["input_schema"] = tool["input_schema"]
+
+            tool_schemas.append(schema)
+
+        attributes["anthropic.tools.schemas"] = json.dumps(tool_schemas)
+
+    except Exception as e:
+        logger.debug(f"[agentops.instrumentation.anthropic] Error extracting tool definitions: {e}")
+
+    return attributes
+
+
+def extract_tool_use_blocks(content_blocks: List[Any]) -> Optional[List[Dict[str, Any]]]:
+    """Extract tool use blocks from message content.
+
+    Analyzes message content blocks to find and extract tool use information.
+    This is used to track which tools the model called and with what parameters.
+
+    Args:
+        content_blocks: List of content blocks from a Message
+
+    Returns:
+        List of tool use information or None if no tools used
+    """
+    if not content_blocks:
+        return None
+
+    try:
+        tool_uses = []
+
+        for block in content_blocks:
+            if hasattr(block, "type") and block.type == "tool_use":
+                tool_use = {
+                    "name": block.name if hasattr(block, "name") else "unknown",
+                    "id": block.id if hasattr(block, "id") else "unknown",
+                }
+
+                if hasattr(block, "input"):
+                    try:
+                        if isinstance(block.input, dict):
+                            tool_use["input"] = block.input
+                        elif isinstance(block.input, str):
+                            tool_use["input"] = json.loads(block.input)
+                        else:
+                            tool_use["input"] = {"raw": str(block.input)}
+                    except Exception:
+                        tool_use["input"] = {"raw": str(block.input)}
+
+                tool_uses.append(tool_use)
+
+        return tool_uses if tool_uses else None
+
+    except Exception as e:
+        logger.debug(f"[agentops.instrumentation.anthropic] Error extracting tool use blocks: {e}")
+        return None
+
+
+def extract_tool_results(content_blocks: List[Any]) -> Optional[List[Dict[str, Any]]]:
+    """Extract tool result blocks from message content.
+
+    Analyzes message content blocks to find and extract tool result information.
+    This is used to track the outputs returned from tool executions.
+
+    Args:
+        content_blocks: List of content blocks from a Message
+
+    Returns:
+        List of tool result information or None if no tool results
+    """
+    if not content_blocks:
+        return None
+
+    try:
+        tool_results = []
+
+        for block in content_blocks:
+            if hasattr(block, "type") and block.type == "tool_result":
+                tool_result = {
+                    "tool_use_id": block.tool_use_id if hasattr(block, "tool_use_id") else "unknown",
+                }
+
+                if hasattr(block, "content"):
+                    try:
+                        if isinstance(block.content, dict):
+                            tool_result["content"] = block.content
+                        elif isinstance(block.content, str):
+                            tool_result["content"] = json.loads(block.content)
+                        else:
+                            tool_result["content"] = {"raw": str(block.content)}
+                    except Exception:
+                        tool_result["content"] = {"raw": str(block.content)}
+
+                tool_results.append(tool_result)
+
+        return tool_results if tool_results else None
+
+    except Exception as e:
+        logger.debug(f"[agentops.instrumentation.anthropic] Error extracting tool results: {e}")
+        return None
+
+
+def get_tool_attributes(message_content: List[Any]) -> AttributeMap:
+    """Extract tool-related attributes from message content.
+
+    Processes message content to extract comprehensive information about
+    tool usage, including both tool calls and tool results. This creates a
+    standardized set of attributes representing the tool interaction flow.
+
+    Args:
+        message_content: List of content blocks from a Message
+
+    Returns:
+        Dictionary of tool-related attributes
+    """
+    attributes = {}
+
+    try:
+        tool_uses = extract_tool_use_blocks(message_content)
+        if tool_uses:
+            for j, tool_use in enumerate(tool_uses):
+                tool_name = tool_use.get("name", "unknown")
+                tool_id = tool_use.get("id", f"tool-call-{j}")
+
+                attributes[MessageAttributes.COMPLETION_TOOL_CALL_ID.format(i=0, j=j)] = tool_id
+                attributes[MessageAttributes.COMPLETION_TOOL_CALL_NAME.format(i=0, j=j)] = tool_name
+                attributes[MessageAttributes.COMPLETION_TOOL_CALL_TYPE.format(i=0, j=j)] = "function"
+
+                tool_input = tool_use.get("input", {})
+                if isinstance(tool_input, dict):
+                    input_str = json.dumps(tool_input)
+                else:
+                    input_str = str(tool_input)
+                attributes[MessageAttributes.COMPLETION_TOOL_CALL_ARGUMENTS.format(i=0, j=j)] = input_str
+
+                attributes[MessageAttributes.TOOL_CALL_ID.format(i=j)] = tool_id
+                attributes[MessageAttributes.TOOL_CALL_NAME.format(i=j)] = tool_name
+                attributes[MessageAttributes.TOOL_CALL_ARGUMENTS.format(i=j)] = input_str
+                attributes[f"{ToolAttributes.TOOL_STATUS}.{j}"] = ToolStatus.EXECUTING.value
+
+            attributes["anthropic.tool_calls.count"] = len(tool_uses)
+
+        tool_results = extract_tool_results(message_content)
+        if tool_results:
+            attributes["anthropic.tool_results"] = json.dumps(tool_results)
+            attributes["anthropic.tool_results.count"] = len(tool_results)
+
+            for j, tool_result in enumerate(tool_results):
+                tool_use_id = tool_result.get("tool_use_id", "unknown")
+
+                tool_index = None
+                for k in range(attributes.get("anthropic.tool_calls.count", 0)):
+                    if attributes.get(MessageAttributes.COMPLETION_TOOL_CALL_ID.format(i=0, j=k)) == tool_use_id:
+                        tool_index = k
+                        break
+
+                if tool_index is not None:
+                    attributes[MessageAttributes.COMPLETION_TOOL_CALL_STATUS.format(i=0, j=tool_index)] = "complete"
+
+                    content = tool_result.get("content", {})
+                    if isinstance(content, dict):
+                        content_str = json.dumps(content)
+                    else:
+                        content_str = str(content)
+
+                    attributes[f"{ToolAttributes.TOOL_STATUS}.{tool_index}"] = ToolStatus.SUCCEEDED.value
+                    attributes[f"{ToolAttributes.TOOL_RESULT}.{tool_index}"] = content_str
+
+                    attributes[f"anthropic.tool_result.{tool_index}.content"] = content_str
+
+    except Exception as e:
+        logger.debug(f"[agentops.instrumentation.anthropic] Error extracting tool attributes: {e}")
+
+    return attributes

agentops/instrumentation/providers/anthropic/event_handler_wrapper.py

@@ -0,0 +1,90 @@
+"""Event handler wrapper for Anthropic's streaming API.
+
+This module provides a wrapper for Anthropic's event handlers to
+track events and metrics during streaming.
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+from opentelemetry.trace import Span
+from agentops.semconv import CoreAttributes
+
+logger = logging.getLogger(__name__)
+
+
+class EventHandleWrapper:
+    """Wrapper for Anthropic's EventHandler.
+
+    This wrapper forwards all events to the original handler while also
+    capturing metrics and adding them to the provided span.
+    """
+
+    def __init__(self, original_handler: Optional[Any], span: Span):
+        """Initialize the wrapper with the original handler and a span.
+
+        Args:
+            original_handler: The original Anthropic event handler (or None)
+            span: The OpenTelemetry span to record metrics to
+        """
+        self._original_handler = original_handler
+        self._span = span
+
+    def _forward_event(self, method_name: str, *args, **kwargs) -> None:
+        """Forward an event to the original handler if it exists.
+
+        Args:
+            method_name: Name of the method to call on the original handler
+            *args: Positional arguments to pass to the method
+            **kwargs: Keyword arguments to pass to the method
+        """
+        try:
+            if self._original_handler is not None and hasattr(self._original_handler, method_name):
+                method = getattr(self._original_handler, method_name)
+                method(*args, **kwargs)
+        except Exception as e:
+            logger.debug(f"Error in event handler {method_name}: {e}")
+
+    def on_event(self, event: Dict[str, Any]) -> None:
+        """Handle any event by forwarding it to the original handler."""
+        self._forward_event("on_event", event)
+
+    def on_text_delta(self, delta: Dict[str, Any], snapshot: Dict[str, Any]) -> None:
+        """Handle a text delta event."""
+        self._forward_event("on_text_delta", delta, snapshot)
+
+    def on_content_block_start(self, content_block_start: Dict[str, Any]) -> None:
+        """Handle a content block start event."""
+        self._forward_event("on_content_block_start", content_block_start)
+
+    def on_content_block_delta(self, delta: Dict[str, Any], snapshot: Dict[str, Any]) -> None:
+        """Handle a content block delta event."""
+        self._forward_event("on_content_block_delta", delta, snapshot)
+
+    def on_content_block_stop(self, content_block_stop: Dict[str, Any]) -> None:
+        """Handle a content block stop event."""
+        self._forward_event("on_content_block_stop", content_block_stop)
+
+    def on_message_start(self, message_start: Dict[str, Any]) -> None:
+        """Handle a message start event."""
+        self._forward_event("on_message_start", message_start)
+
+    def on_message_delta(self, delta: Dict[str, Any], snapshot: Dict[str, Any]) -> None:
+        """Handle a message delta event."""
+        self._forward_event("on_message_delta", delta, snapshot)
+
+    def on_message_stop(self, message_stop: Dict[str, Any]) -> None:
+        """Handle a message stop event."""
+        self._forward_event("on_message_stop", message_stop)
+
+    def on_error(self, error: Exception) -> None:
+        """Handle an error event."""
+        try:
+            self._span.record_exception(error)
+            self._span.set_attribute(CoreAttributes.ERROR_MESSAGE, str(error))
+            self._span.set_attribute(CoreAttributes.ERROR_TYPE, error.__class__.__name__)
+
+            if self._original_handler is not None and hasattr(self._original_handler, "on_error"):
+                self._original_handler.on_error(error)
+        except Exception as e:
+            logger.debug(f"Error in event handler on_error: {e}")

agentops/instrumentation/providers/anthropic/instrumentor.py

@@ -0,0 +1,146 @@
+"""Anthropic API Instrumentation for AgentOps
+
+This module provides instrumentation for the Anthropic API, implementing OpenTelemetry
+instrumentation for Claude model requests and responses.
+
+We focus on instrumenting the following key endpoints:
+- Client.messages.create - The main completion endpoint
+- Client.messages.stream - Streaming API for messages
+- Client.completions.create - The legacy completion endpoint
+- Streaming responses - Special handling for streaming responses
+- Tool-using completions - Capturing tool usage information
+
+The instrumentation captures:
+1. Request parameters (model, max_tokens, temperature, etc.)
+2. Response data (completion content, token usage, etc.)
+3. Timing information (latency, time to first token, etc.)
+4. Tool usage information (tool calls, tool outputs)
+
+1. Standard Method Wrapping:
+   - Uses the common wrappers module to wrap methods with tracers
+   - Applies to both sync and async methods
+   - Captures request/response attributes via attribute extractors
+
+2. Streaming Approach:
+   - Special handling for streaming responses
+   - Uses direct wrapt.wrap_function_wrapper for stream methods
+   - Captures events as they arrive rather than waiting for completion
+   - Maintains span context across multiple events
+"""
+
+from typing import Dict, Any
+from wrapt import wrap_function_wrapper
+
+from agentops.logging import logger
+from agentops.instrumentation.common import CommonInstrumentor, InstrumentorConfig, WrapConfig, StandardMetrics
+from agentops.instrumentation.providers.anthropic import LIBRARY_NAME, LIBRARY_VERSION
+from agentops.instrumentation.providers.anthropic.attributes.message import (
+    get_message_attributes,
+    get_completion_attributes,
+)
+from agentops.instrumentation.providers.anthropic.stream_wrapper import (
+    messages_stream_wrapper,
+    messages_stream_async_wrapper,
+)
+from opentelemetry.metrics import Meter
+from opentelemetry.instrumentation.utils import unwrap as otel_unwrap
+
+
+class AnthropicInstrumentor(CommonInstrumentor):
+    """An instrumentor for Anthropic's Claude API.
+
+    This class provides instrumentation for Anthropic's Claude API by wrapping key methods
+    in the client library and capturing telemetry data. It supports both synchronous and
+    asynchronous API calls, including streaming responses.
+
+    The instrumentor wraps the following methods:
+    - messages.create: For the modern Messages API
+    - completions.create: For the legacy Completions API
+    - messages.stream: For streaming responses
+
+    It captures metrics including token usage, operation duration, and exceptions.
+    """
+
+    def __init__(self):
+        # Define wrapped methods
+        wrapped_methods = [
+            # Main messages.create (modern API)
+            WrapConfig(
+                trace_name="anthropic.messages.create",
+                package="anthropic.resources.messages",
+                class_name="Messages",
+                method_name="create",
+                handler=get_message_attributes,
+            ),
+            # Async variant
+            WrapConfig(
+                trace_name="anthropic.messages.create",
+                package="anthropic.resources.messages",
+                class_name="AsyncMessages",
+                method_name="create",
+                handler=get_message_attributes,
+                is_async=True,
+            ),
+            # Legacy completions API
+            WrapConfig(
+                trace_name="anthropic.completions.create",
+                package="anthropic.resources.completions",
+                class_name="Completions",
+                method_name="create",
+                handler=get_completion_attributes,
+            ),
+            # Async variant of legacy API
+            WrapConfig(
+                trace_name="anthropic.completions.create",
+                package="anthropic.resources.completions",
+                class_name="AsyncCompletions",
+                method_name="create",
+                handler=get_completion_attributes,
+                is_async=True,
+            ),
+        ]
+
+        # Create instrumentor config
+        config = InstrumentorConfig(
+            library_name=LIBRARY_NAME,
+            library_version=LIBRARY_VERSION,
+            wrapped_methods=wrapped_methods,
+            metrics_enabled=True,
+            dependencies=["anthropic >= 0.7.0"],
+        )
+
+        super().__init__(config)
+
+    def _create_metrics(self, meter: Meter) -> Dict[str, Any]:
+        """Create metrics for Anthropic instrumentation."""
+        # Use standard metrics from common module
+        return StandardMetrics.create_standard_metrics(meter)
+
+    def _custom_wrap(self, **kwargs):
+        """Perform custom wrapping for streaming methods."""
+        # Special handling for streaming responses
+        # Uses direct wrapt.wrap_function_wrapper for stream methods
+        # This approach captures events as they arrive rather than waiting for completion
+        try:
+            wrap_function_wrapper(
+                "anthropic.resources.messages.messages",
+                "Messages.stream",
+                messages_stream_wrapper(self._tracer),
+            )
+
+            wrap_function_wrapper(
+                "anthropic.resources.messages.messages",
+                "AsyncMessages.stream",
+                messages_stream_async_wrapper(self._tracer),
+            )
+        except (AttributeError, ModuleNotFoundError):
+            logger.debug("Failed to wrap Anthropic streaming methods")
+
+    def _custom_unwrap(self, **kwargs):
+        """Perform custom unwrapping for streaming methods."""
+        # Unwrap streaming methods
+        try:
+            otel_unwrap("anthropic.resources.messages.messages", "Messages.stream")
+            otel_unwrap("anthropic.resources.messages.messages", "AsyncMessages.stream")
+        except (AttributeError, ModuleNotFoundError):
+            logger.debug("Failed to unwrap Anthropic streaming methods")