genai-otel-instrument 0.1.24__py3-none-any.whl

genai_otel/instrumentors/anthropic_instrumentor.py

@@ -0,0 +1,134 @@
+"""OpenTelemetry instrumentor for the Anthropic Claude SDK.
+
+This instrumentor automatically traces calls to the Anthropic API, capturing
+relevant attributes such as model name, message count, and token usage.
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+from ..config import OTelConfig
+from .base import BaseInstrumentor
+
+logger = logging.getLogger(__name__)
+
+
+class AnthropicInstrumentor(BaseInstrumentor):
+    """Instrumentor for Anthropic Claude SDK"""
+
+    def __init__(self):
+        """Initialize the instrumentor."""
+        super().__init__()
+        self._anthropic_available = False
+        self._check_availability()
+
+    def _check_availability(self):
+        """Check if Anthropic library is available."""
+        try:
+            import anthropic
+
+            self._anthropic_available = True
+            logger.debug("Anthropic library detected and available for instrumentation")
+        except ImportError:
+            logger.debug("Anthropic library not installed, instrumentation will be skipped")
+            self._anthropic_available = False
+
+    def instrument(self, config: OTelConfig):
+        """Instrument Anthropic SDK if available.
+
+        Args:
+            config (OTelConfig): The OpenTelemetry configuration object.
+        """
+        if not self._anthropic_available:
+            logger.debug("Skipping Anthropic instrumentation - library not available")
+            return
+
+        self.config = config
+
+        try:
+            import anthropic
+            import wrapt
+
+            if hasattr(anthropic, "Anthropic"):
+                original_init = anthropic.Anthropic.__init__
+
+                def wrapped_init(wrapped, instance, args, kwargs):
+                    result = wrapped(*args, **kwargs)
+                    self._instrument_client(instance)
+                    return result
+
+                anthropic.Anthropic.__init__ = wrapt.FunctionWrapper(original_init, wrapped_init)
+                self._instrumented = True
+                logger.info("Anthropic instrumentation enabled")
+
+        except Exception as e:
+            logger.error("Failed to instrument Anthropic: %s", e, exc_info=True)
+            if config.fail_on_error:
+                raise
+
+    def _instrument_client(self, client):
+        """Instrument Anthropic client methods.
+
+        Args:
+            client: The Anthropic client instance to instrument.
+        """
+        if hasattr(client, "messages") and hasattr(client.messages, "create"):
+            original_create = client.messages.create
+            instrumented_create_method = self.create_span_wrapper(
+                span_name="anthropic.messages.create",
+                extract_attributes=self._extract_anthropic_attributes,
+            )(original_create)
+            client.messages.create = instrumented_create_method
+
+    def _extract_anthropic_attributes(
+        self, instance: Any, args: Any, kwargs: Any
+    ) -> Dict[str, Any]:
+        """Extract attributes from Anthropic API call.
+
+        Args:
+            instance: The client instance.
+            args: Positional arguments.
+            kwargs: Keyword arguments.
+
+        Returns:
+            Dict[str, Any]: Dictionary of attributes to set on the span.
+        """
+        attrs = {}
+        model = kwargs.get("model", "unknown")
+        messages = kwargs.get("messages", [])
+
+        attrs["gen_ai.system"] = "anthropic"
+        attrs["gen_ai.request.model"] = model
+        attrs["gen_ai.request.message_count"] = len(messages)
+        return attrs
+
+    def _extract_usage(self, result) -> Optional[Dict[str, int]]:
+        """Extract token usage from Anthropic response.
+
+        Args:
+            result: The API response object.
+
+        Returns:
+            Optional[Dict[str, int]]: Dictionary with token counts or None.
+        """
+        if hasattr(result, "usage") and result.usage:
+            usage = result.usage
+            usage_dict = {
+                "prompt_tokens": getattr(usage, "input_tokens", 0),
+                "completion_tokens": getattr(usage, "output_tokens", 0),
+                "total_tokens": getattr(usage, "input_tokens", 0)
+                + getattr(usage, "output_tokens", 0),
+            }
+
+            # Extract cache tokens for Anthropic models (Phase 3.2)
+            # cache_read_input_tokens: Tokens that were read from cache
+            # cache_creation_input_tokens: Tokens that were written to cache
+            if hasattr(usage, "cache_read_input_tokens"):
+                usage_dict["cache_read_input_tokens"] = getattr(usage, "cache_read_input_tokens", 0)
+            if hasattr(usage, "cache_creation_input_tokens"):
+                usage_dict["cache_creation_input_tokens"] = getattr(
+                    usage, "cache_creation_input_tokens", 0
+                )
+
+            return usage_dict
+        return None

genai_otel/instrumentors/anyscale_instrumentor.py

@@ -0,0 +1,27 @@
+"""OpenTelemetry instrumentor for Anyscale Endpoints.
+
+This instrumentor integrates with Anyscale Endpoints, which often leverage
+OpenAI-compatible APIs. It ensures that calls made to Anyscale services are
+properly traced and attributed within the OpenTelemetry ecosystem.
+"""
+
+from typing import Dict, Optional
+
+from ..config import OTelConfig
+from .base import BaseInstrumentor
+
+
+class AnyscaleInstrumentor(BaseInstrumentor):
+    """Instrumentor for Anyscale Endpoints"""
+
+    def instrument(self, config: OTelConfig):
+        self.config = config
+        try:
+            # Anyscale uses OpenAI SDK, already instrumented
+            pass
+
+        except ImportError:
+            pass
+
+    def _extract_usage(self, result) -> Optional[Dict[str, int]]:
+        return None

genai_otel/instrumentors/autogen_instrumentor.py

@@ -0,0 +1,394 @@
+"""OpenTelemetry instrumentor for Microsoft AutoGen framework.
+
+This instrumentor automatically traces multi-agent conversations, group chats,
+and agent interactions using the Microsoft AutoGen framework.
+
+Note: AutoGen is entering maintenance mode and merging with Semantic Kernel
+into the Microsoft Agent Framework (public preview Oct 2025). This instrumentor
+supports the current AutoGen release.
+
+Requirements:
+    pip install pyautogen  # or autogen (legacy package name)
+"""
+
+import json
+import logging
+from typing import Any, Dict, Optional
+
+from ..config import OTelConfig
+from .base import BaseInstrumentor
+
+logger = logging.getLogger(__name__)
+
+
+class AutoGenInstrumentor(BaseInstrumentor):
+    """Instrumentor for Microsoft AutoGen framework"""
+
+    def __init__(self):
+        """Initialize the instrumentor."""
+        super().__init__()
+        self._autogen_available = False
+        self._check_availability()
+
+    def _check_availability(self):
+        """Check if AutoGen library is available."""
+        # Try pyautogen first (newer package name)
+        try:
+            import autogen
+
+            self._autogen_available = True
+            logger.debug("AutoGen library detected and available for instrumentation")
+            return
+        except ImportError:
+            pass
+
+        # Fall back to older package name
+        try:
+            import pyautogen
+
+            self._autogen_available = True
+            logger.debug("AutoGen library (pyautogen) detected and available for instrumentation")
+            return
+        except ImportError:
+            logger.debug("AutoGen library not installed, instrumentation will be skipped")
+            self._autogen_available = False
+
+    def instrument(self, config: OTelConfig):
+        """Instrument AutoGen framework if available.
+
+        Args:
+            config (OTelConfig): The OpenTelemetry configuration object.
+        """
+        if not self._autogen_available:
+            logger.debug("Skipping AutoGen instrumentation - library not available")
+            return
+
+        self.config = config
+
+        try:
+            import wrapt
+
+            # Try both package names
+            try:
+                import autogen
+            except ImportError:
+                import pyautogen as autogen
+
+            # Instrument ConversableAgent.initiate_chat (main conversation method)
+            if hasattr(autogen, "ConversableAgent"):
+                if hasattr(autogen.ConversableAgent, "initiate_chat"):
+                    original_initiate = autogen.ConversableAgent.initiate_chat
+                    autogen.ConversableAgent.initiate_chat = wrapt.FunctionWrapper(
+                        original_initiate, self._wrap_initiate_chat
+                    )
+
+            # Instrument GroupChat.run (group chat orchestration)
+            if hasattr(autogen, "GroupChat"):
+                # GroupChat typically has select_speaker method for agent selection
+                if hasattr(autogen.GroupChat, "select_speaker"):
+                    original_select = autogen.GroupChat.select_speaker
+                    autogen.GroupChat.select_speaker = wrapt.FunctionWrapper(
+                        original_select, self._wrap_select_speaker
+                    )
+
+            # Instrument GroupChatManager if available
+            if hasattr(autogen, "GroupChatManager"):
+                if hasattr(autogen.GroupChatManager, "run"):
+                    original_run = autogen.GroupChatManager.run
+                    autogen.GroupChatManager.run = wrapt.FunctionWrapper(
+                        original_run, self._wrap_group_chat_run
+                    )
+
+            self._instrumented = True
+            logger.info("AutoGen instrumentation enabled")
+
+        except Exception as e:
+            logger.error("Failed to instrument AutoGen: %s", e, exc_info=True)
+            if config.fail_on_error:
+                raise
+
+    def _wrap_initiate_chat(self, wrapped, instance, args, kwargs):
+        """Wrap ConversableAgent.initiate_chat method with span.
+
+        Args:
+            wrapped: The original method.
+            instance: The ConversableAgent instance.
+            args: Positional arguments.
+            kwargs: Keyword arguments.
+        """
+        return self.create_span_wrapper(
+            span_name="autogen.initiate_chat",
+            extract_attributes=self._extract_chat_attributes,
+        )(wrapped)(instance, *args, **kwargs)
+
+    def _wrap_select_speaker(self, wrapped, instance, args, kwargs):
+        """Wrap GroupChat.select_speaker method with span.
+
+        Args:
+            wrapped: The original method.
+            instance: The GroupChat instance.
+            args: Positional arguments.
+            kwargs: Keyword arguments.
+        """
+        return self.create_span_wrapper(
+            span_name="autogen.group_chat.select_speaker",
+            extract_attributes=self._extract_group_chat_attributes,
+        )(wrapped)(instance, *args, **kwargs)
+
+    def _wrap_group_chat_run(self, wrapped, instance, args, kwargs):
+        """Wrap GroupChatManager.run method with span.
+
+        Args:
+            wrapped: The original method.
+            instance: The GroupChatManager instance.
+            args: Positional arguments.
+            kwargs: Keyword arguments.
+        """
+        return self.create_span_wrapper(
+            span_name="autogen.group_chat.run",
+            extract_attributes=self._extract_group_chat_manager_attributes,
+        )(wrapped)(instance, *args, **kwargs)
+
+    def _extract_chat_attributes(self, instance: Any, args: Any, kwargs: Any) -> Dict[str, Any]:
+        """Extract attributes from ConversableAgent.initiate_chat call.
+
+        Args:
+            instance: The ConversableAgent instance (sender).
+            args: Positional arguments (recipient, message, etc.).
+            kwargs: Keyword arguments.
+
+        Returns:
+            Dict[str, Any]: Dictionary of attributes to set on the span.
+        """
+        attrs = {}
+
+        # Core attributes
+        attrs["gen_ai.system"] = "autogen"
+        attrs["gen_ai.operation.name"] = "conversation.initiate"
+
+        # Extract sender agent name
+        if hasattr(instance, "name"):
+            attrs["autogen.agent.name"] = instance.name
+            attrs["autogen.conversation.sender"] = instance.name
+
+        # Extract sender agent type
+        agent_type = type(instance).__name__
+        attrs["autogen.agent.type"] = agent_type
+
+        # Extract recipient agent (first positional argument)
+        recipient = None
+        if len(args) > 0:
+            recipient = args[0]
+        else:
+            recipient = kwargs.get("recipient")
+
+        if recipient:
+            if hasattr(recipient, "name"):
+                attrs["autogen.conversation.recipient"] = recipient.name
+
+            recipient_type = type(recipient).__name__
+            attrs["autogen.recipient.type"] = recipient_type
+
+        # Extract message (second positional argument or kwarg)
+        message = None
+        if len(args) > 1:
+            message = args[1]
+        else:
+            message = kwargs.get("message")
+
+        if message:
+            # Message can be string or dict
+            if isinstance(message, str):
+                attrs["autogen.message"] = message[:500]  # Truncate
+                attrs["autogen.message.type"] = "string"
+            elif isinstance(message, dict):
+                if "content" in message:
+                    attrs["autogen.message"] = str(message["content"])[:500]
+                attrs["autogen.message.type"] = "dict"
+            else:
+                attrs["autogen.message.type"] = str(type(message).__name__)
+
+        # Extract max_turns if specified
+        max_turns = kwargs.get("max_turns")
+        if max_turns is not None:
+            attrs["autogen.conversation.max_turns"] = max_turns
+
+        # Extract silent mode
+        if "silent" in kwargs:
+            attrs["autogen.conversation.silent"] = kwargs["silent"]
+
+        # Extract clear_history flag
+        if "clear_history" in kwargs:
+            attrs["autogen.conversation.clear_history"] = kwargs["clear_history"]
+
+        return attrs
+
+    def _extract_group_chat_attributes(
+        self, instance: Any, args: Any, kwargs: Any
+    ) -> Dict[str, Any]:
+        """Extract attributes from GroupChat.select_speaker call.
+
+        Args:
+            instance: The GroupChat instance.
+            args: Positional arguments.
+            kwargs: Keyword arguments.
+
+        Returns:
+            Dict[str, Any]: Dictionary of attributes to set on the span.
+        """
+        attrs = {}
+
+        # Core attributes
+        attrs["gen_ai.system"] = "autogen"
+        attrs["gen_ai.operation.name"] = "group_chat.select_speaker"
+
+        # Extract agent count
+        if hasattr(instance, "agents") and instance.agents:
+            attrs["autogen.group_chat.agent_count"] = len(instance.agents)
+
+            # Extract agent names
+            agent_names = [getattr(agent, "name", "unknown") for agent in instance.agents]
+            attrs["autogen.group_chat.agents"] = agent_names[:10]  # Limit to 10
+
+        # Extract selection mode/method
+        if hasattr(instance, "speaker_selection_method"):
+            attrs["autogen.group_chat.selection_mode"] = instance.speaker_selection_method
+
+        # Extract max_round
+        if hasattr(instance, "max_round"):
+            attrs["autogen.group_chat.max_round"] = instance.max_round
+
+        return attrs
+
+    def _extract_group_chat_manager_attributes(
+        self, instance: Any, args: Any, kwargs: Any
+    ) -> Dict[str, Any]:
+        """Extract attributes from GroupChatManager.run call.
+
+        Args:
+            instance: The GroupChatManager instance.
+            args: Positional arguments.
+            kwargs: Keyword arguments.
+
+        Returns:
+            Dict[str, Any]: Dictionary of attributes to set on the span.
+        """
+        attrs = {}
+
+        # Core attributes
+        attrs["gen_ai.system"] = "autogen"
+        attrs["gen_ai.operation.name"] = "group_chat.run"
+
+        # Extract manager name
+        if hasattr(instance, "name"):
+            attrs["autogen.manager.name"] = instance.name
+
+        # Extract groupchat info
+        if hasattr(instance, "groupchat"):
+            groupchat = instance.groupchat
+
+            if hasattr(groupchat, "agents") and groupchat.agents:
+                attrs["autogen.group_chat.agent_count"] = len(groupchat.agents)
+
+                agent_names = [getattr(agent, "name", "unknown") for agent in groupchat.agents]
+                attrs["autogen.group_chat.agents"] = agent_names[:10]
+
+            if hasattr(groupchat, "speaker_selection_method"):
+                attrs["autogen.group_chat.selection_mode"] = groupchat.speaker_selection_method
+
+        return attrs
+
+    def _extract_usage(self, result) -> Optional[Dict[str, int]]:
+        """Extract token usage from conversation result.
+
+        Note: AutoGen doesn't directly expose token usage in results.
+        Token usage is captured by underlying LLM provider instrumentors.
+
+        Args:
+            result: The conversation result.
+
+        Returns:
+            Optional[Dict[str, int]]: Dictionary with token counts or None.
+        """
+        # AutoGen doesn't expose usage directly
+        # Token usage is captured by LLM provider instrumentors (OpenAI, etc.)
+        # We could try to aggregate if AutoGen provides usage info in the future
+        if hasattr(result, "usage"):
+            try:
+                usage = result.usage
+                return {
+                    "prompt_tokens": getattr(usage, "prompt_tokens", 0),
+                    "completion_tokens": getattr(usage, "completion_tokens", 0),
+                    "total_tokens": getattr(usage, "total_tokens", 0),
+                }
+            except Exception as e:
+                logger.debug("Failed to extract token usage: %s", e)
+
+        return None
+
+    def _extract_response_attributes(self, result) -> Dict[str, Any]:
+        """Extract response attributes from conversation result.
+
+        Args:
+            result: The conversation result.
+
+        Returns:
+            Dict[str, Any]: Dictionary of response attributes.
+        """
+        attrs = {}
+
+        try:
+            # AutoGen results are typically ChatResult objects
+            if hasattr(result, "chat_history"):
+                # Extract chat history length
+                attrs["autogen.conversation.messages"] = len(result.chat_history)
+
+                # Extract last message content (truncated)
+                if result.chat_history:
+                    last_message = result.chat_history[-1]
+                    if isinstance(last_message, dict):
+                        if "content" in last_message:
+                            attrs["autogen.conversation.last_message"] = str(
+                                last_message["content"]
+                            )[:500]
+                        if "role" in last_message:
+                            attrs["autogen.conversation.last_role"] = last_message["role"]
+                        if "name" in last_message:
+                            attrs["autogen.conversation.last_speaker"] = last_message["name"]
+
+            # Extract cost if available
+            if hasattr(result, "cost"):
+                try:
+                    cost = result.cost
+                    if isinstance(cost, dict):
+                        for key, value in cost.items():
+                            attrs[f"autogen.cost.{key}"] = value
+                    else:
+                        attrs["autogen.cost"] = cost
+                except Exception as e:
+                    logger.debug("Failed to extract cost: %s", e)
+
+            # Extract summary if available
+            if hasattr(result, "summary"):
+                attrs["autogen.conversation.summary"] = str(result.summary)[:500]
+
+        except Exception as e:
+            logger.debug("Failed to extract response attributes: %s", e)
+
+        return attrs
+
+    def _extract_finish_reason(self, result) -> Optional[str]:
+        """Extract finish reason from conversation result.
+
+        Args:
+            result: The conversation result.
+
+        Returns:
+            Optional[str]: The finish reason string or None if not available.
+        """
+        # Try to determine if conversation completed successfully
+        if hasattr(result, "chat_history"):
+            # If we have chat history, conversation completed
+            return "completed"
+
+        return None

genai_otel/instrumentors/aws_bedrock_instrumentor.py

@@ -0,0 +1,94 @@
+import json
+import logging
+from typing import Any, Dict, Optional
+
+from ..config import OTelConfig
+from .base import BaseInstrumentor
+
+logger = logging.getLogger(__name__)
+
+
+class AWSBedrockInstrumentor(BaseInstrumentor):
+    """Instrumentor for AWS Bedrock"""
+
+    def __init__(self):
+        """Initialize the instrumentor."""
+        super().__init__()
+        self._boto3_available = False
+        self._check_availability()
+
+    def _check_availability(self):
+        """Check if boto3 library is available."""
+        try:
+            import boto3  # Moved to top
+
+            self._boto3_available = True
+            logger.debug("boto3 library detected and available for instrumentation")
+        except ImportError:
+            logger.debug("boto3 library not installed, instrumentation will be skipped")
+            self._boto3_available = False
+
+    def instrument(self, config: OTelConfig):
+        self.config = config
+        try:
+            import boto3  # Moved to top
+
+            original_client = boto3.client
+
+            def wrapped_client(*args, **kwargs):
+                client = original_client(*args, **kwargs)
+                if args and args[0] == "bedrock-runtime":
+                    self._instrument_bedrock_client(client)
+                return client
+
+            boto3.client = wrapped_client
+
+        except ImportError:
+            pass
+
+    def _instrument_bedrock_client(self, client):
+        if hasattr(client, "invoke_model"):
+            instrumented_invoke_method = self.create_span_wrapper(
+                span_name="aws.bedrock.invoke_model",
+                extract_attributes=self._extract_aws_bedrock_attributes,
+            )
+            client.invoke_model = instrumented_invoke_method
+
+    def _extract_aws_bedrock_attributes(
+        self, instance: Any, args: Any, kwargs: Any
+    ) -> Dict[str, Any]:  # pylint: disable=W0613
+        attrs = {}
+        model_id = kwargs.get("modelId", "unknown")
+
+        attrs["gen_ai.system"] = "aws_bedrock"
+        attrs["gen_ai.request.model"] = model_id
+        return attrs
+
+    def _extract_usage(self, result) -> Optional[Dict[str, int]]:  # pylint: disable=R1705
+        if hasattr(result, "get"):
+            content_type = result.get("contentType", "").lower()
+            body_str = result.get("body", "")
+
+            if "application/json" in content_type and body_str:
+                try:
+                    body = json.loads(body_str)
+                    if "usage" in body and isinstance(body["usage"], dict):
+                        usage = body["usage"]
+                        return {
+                            "prompt_tokens": getattr(usage, "inputTokens", 0),
+                            "completion_tokens": getattr(usage, "outputTokens", 0),
+                            "total_tokens": getattr(usage, "inputTokens", 0)
+                            + getattr(usage, "outputTokens", 0),
+                        }
+                    elif "usageMetadata" in body and isinstance(body["usageMetadata"], dict):
+                        usage = body["usageMetadata"]
+                        return {
+                            "prompt_tokens": getattr(usage, "promptTokenCount", 0),
+                            "completion_tokens": getattr(usage, "candidatesTokenCount", 0),
+                            "total_tokens": getattr(usage, "totalTokenCount", 0),
+                        }
+                except json.JSONDecodeError:
+                    logger.debug("Failed to parse Bedrock response body as JSON.")
+                except Exception as e:
+                    logger.debug("Error extracting usage from Bedrock response: %s", e)
+        return None