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

agentops/instrumentation/agentic/xpander/trace_probe.py

@@ -0,0 +1,86 @@
+"""Xpander trace probe for automatic instrumentation activation.
+
+This module provides automatic instrumentation for Xpander SDK when imported.
+It should be imported early in the application lifecycle to ensure all
+Xpander interactions are captured.
+"""
+
+import logging
+from agentops.instrumentation.agentic.xpander.instrumentor import XpanderInstrumentor
+
+logger = logging.getLogger(__name__)
+
+# Global instrumentor instance
+_instrumentor = None
+
+
+def activate_xpander_instrumentation():
+    """Activate Xpander instrumentation."""
+    global _instrumentor
+
+    if _instrumentor is None:
+        try:
+            _instrumentor = XpanderInstrumentor()
+            _instrumentor.instrument()
+            logger.info("Xpander instrumentation activated successfully")
+        except Exception as e:
+            logger.error(f"Failed to activate Xpander instrumentation: {e}")
+            _instrumentor = None
+
+    return _instrumentor
+
+
+def deactivate_xpander_instrumentation():
+    """Deactivate Xpander instrumentation."""
+    global _instrumentor
+
+    if _instrumentor is not None:
+        try:
+            _instrumentor.uninstrument()
+            logger.info("Xpander instrumentation deactivated successfully")
+        except Exception as e:
+            logger.error(f"Failed to deactivate Xpander instrumentation: {e}")
+        finally:
+            _instrumentor = None
+
+
+def get_instrumentor():
+    """Get the active instrumentor instance."""
+    return _instrumentor
+
+
+# Stub functions for backward compatibility
+def wrap_openai_call_for_xpander(openai_call_func, purpose="general"):
+    """Backward compatibility stub - functionality now handled by auto-instrumentation."""
+    logger.debug(f"wrap_openai_call_for_xpander called with purpose: {purpose}")
+    return openai_call_func
+
+
+def is_xpander_session_active():
+    """Check if xpander session is active."""
+    return _instrumentor is not None
+
+
+def get_active_xpander_session():
+    """Get active xpander session."""
+    return _instrumentor._context if _instrumentor else None
+
+
+# Convenience functions for cleaner OpenAI integration
+def wrap_openai_analysis(openai_call_func):
+    """Wrap OpenAI calls for analysis/reasoning steps."""
+    return wrap_openai_call_for_xpander(openai_call_func, "analysis")
+
+
+def wrap_openai_planning(openai_call_func):
+    """Wrap OpenAI calls for planning steps."""
+    return wrap_openai_call_for_xpander(openai_call_func, "planning")
+
+
+def wrap_openai_synthesis(openai_call_func):
+    """Wrap OpenAI calls for synthesis/summary steps."""
+    return wrap_openai_call_for_xpander(openai_call_func, "synthesis")
+
+
+# Note: Auto-activation is now handled by the main AgentOps instrumentation system
+# activate_xpander_instrumentation()

agentops/instrumentation/agentic/xpander/version.py

@@ -0,0 +1,3 @@
+"""Version information for xpander instrumentation."""
+
+__version__ = "1.0.0"

agentops/instrumentation/common/README.md

@@ -0,0 +1,65 @@
+# AgentOps Instrumentation Common Module
+
+The `agentops.instrumentation.common` module provides shared utilities for OpenTelemetry instrumentation across different LLM service providers.
+
+## Core Components
+
+### Attribute Handler Example
+
+Attribute handlers extract data from method inputs and outputs:
+
+```python
+from typing import Optional, Any, Tuple, Dict
+from agentops.instrumentation.common.attributes import AttributeMap
+from agentops.semconv import SpanAttributes
+
+def my_attribute_handler(args: Optional[Tuple] = None, kwargs: Optional[Dict] = None, return_value: Optional[Any] = None) -> AttributeMap:
+    attributes = {}
+    
+    # Extract attributes from kwargs (method inputs)
+    if kwargs:
+        if "model" in kwargs:
+            attributes[SpanAttributes.MODEL_NAME] = kwargs["model"]
+        # ...
+    
+    # Extract attributes from return value (method outputs)
+    if return_value:
+        if hasattr(return_value, "model"):
+            attributes[SpanAttributes.LLM_RESPONSE_MODEL] = return_value.model
+        # ...
+    
+    return attributes
+```
+
+### `WrapConfig` Class
+
+Config object defining how a method should be wrapped:
+
+```python
+from agentops.instrumentation.common.wrappers import WrapConfig
+from opentelemetry.trace import SpanKind
+
+config = WrapConfig(
+    trace_name="llm.completion",    # Name that will appear in trace spans
+    package="openai.resources",     # Path to the module containing the class
+    class_name="Completions",       # Name of the class containing the method
+    method_name="create",           # Name of the method to wrap
+    handler=my_attribute_handler,   # Function that extracts attributes
+    span_kind=SpanKind.CLIENT       # Type of span to create
+)
+```
+
+### Wrapping/Unwrapping Methods
+
+```python
+from opentelemetry.trace import get_tracer
+from agentops.instrumentation.common.wrappers import wrap, unwrap
+
+# Create a tracer and wrap a method
+tracer = get_tracer("openai", "0.0.0")
+wrap(config, tracer)
+
+# Later, unwrap the method
+unwrap(config)
+```
+

agentops/instrumentation/common/attributes.py

@@ -98,8 +98,7 @@ class IndexedAttribute(Protocol):
     formatting of attribute keys based on the indices.
     """
 
-    def format(self, *, i: int, j: Optional[int] = None) -> str:
-        ...
+    def format(self, *, i: int, j: Optional[int] = None) -> str: ...
 
 
 IndexedAttributeMap = Dict[IndexedAttribute, str]  # target_attribute_key: source_attribute

agentops/instrumentation/providers/anthropic/__init__.py

@@ -0,0 +1,24 @@
+"""Anthropic API instrumentation.
+
+This module provides instrumentation for the Anthropic API,
+including chat completions, streaming, and event handling.
+"""
+
+import logging
+from agentops.instrumentation.common import LibraryInfo
+
+logger = logging.getLogger(__name__)
+
+# Library information
+_library_info = LibraryInfo(name="anthropic")
+LIBRARY_NAME = _library_info.name
+LIBRARY_VERSION = _library_info.version
+
+# Import after defining constants to avoid circular imports
+from agentops.instrumentation.providers.anthropic.instrumentor import AnthropicInstrumentor  # noqa: E402
+
+__all__ = [
+    "LIBRARY_NAME",
+    "LIBRARY_VERSION",
+    "AnthropicInstrumentor",
+]

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

@@ -0,0 +1,23 @@
+"""Attribute extraction for Anthropic API instrumentation."""
+
+from agentops.instrumentation.providers.anthropic.attributes.common import get_common_instrumentation_attributes
+from agentops.instrumentation.providers.anthropic.attributes.message import (
+    get_message_attributes,
+    get_completion_attributes,
+)
+from agentops.instrumentation.providers.anthropic.attributes.tools import (
+    extract_tool_definitions,
+    extract_tool_use_blocks,
+    extract_tool_results,
+    get_tool_attributes,
+)
+
+__all__ = [
+    "get_common_instrumentation_attributes",
+    "get_message_attributes",
+    "get_completion_attributes",
+    "extract_tool_definitions",
+    "extract_tool_use_blocks",
+    "extract_tool_results",
+    "get_tool_attributes",
+]

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

@@ -0,0 +1,64 @@
+"""Common attribute extraction for Anthropic instrumentation."""
+
+from typing import Dict, Any
+
+from agentops.semconv import InstrumentationAttributes, SpanAttributes
+from agentops.instrumentation.common.attributes import AttributeMap, get_common_attributes
+from agentops.instrumentation.providers.anthropic import LIBRARY_NAME, LIBRARY_VERSION
+
+
+def get_common_instrumentation_attributes() -> AttributeMap:
+    """Get common instrumentation attributes for the Anthropic instrumentation.
+
+    This combines the generic AgentOps attributes with Anthropic specific library attributes.
+
+    Returns:
+        Dictionary of common instrumentation attributes
+    """
+    attributes = get_common_attributes()
+    attributes.update(
+        {
+            InstrumentationAttributes.LIBRARY_NAME: LIBRARY_NAME,
+            InstrumentationAttributes.LIBRARY_VERSION: LIBRARY_VERSION,
+        }
+    )
+    return attributes
+
+
+def extract_request_attributes(kwargs: Dict[str, Any]) -> AttributeMap:
+    """Extract all request attributes from kwargs.
+
+    This consolidated function extracts all relevant attributes from the request
+    kwargs, including model, system prompt, messages, max_tokens, temperature,
+    and other parameters. It replaces the individual extraction functions with
+    a single comprehensive approach.
+
+    Args:
+        kwargs: Request keyword arguments
+
+    Returns:
+        Dictionary of extracted request attributes
+    """
+    attributes = {}
+
+    # Extract model
+    if "model" in kwargs:
+        attributes[SpanAttributes.LLM_REQUEST_MODEL] = kwargs["model"]
+
+    # Extract max_tokens
+    if "max_tokens" in kwargs:
+        attributes[SpanAttributes.LLM_REQUEST_MAX_TOKENS] = kwargs["max_tokens"]
+
+    # Extract temperature
+    if "temperature" in kwargs:
+        attributes[SpanAttributes.LLM_REQUEST_TEMPERATURE] = kwargs["temperature"]
+
+    # Extract top_p
+    if "top_p" in kwargs:
+        attributes[SpanAttributes.LLM_REQUEST_TOP_P] = kwargs["top_p"]
+
+    # Extract streaming
+    if "stream" in kwargs:
+        attributes[SpanAttributes.LLM_REQUEST_STREAMING] = kwargs["stream"]
+
+    return attributes