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

agentops/instrumentation/providers/openai/wrappers/embeddings.py

@@ -0,0 +1,94 @@
+"""Embeddings wrapper for OpenAI instrumentation.
+
+This module provides attribute extraction for OpenAI embeddings API.
+"""
+
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+from agentops.instrumentation.providers.openai.utils import is_openai_v1
+from agentops.instrumentation.providers.openai.wrappers.shared import (
+    model_as_dict,
+    should_send_prompts,
+)
+from agentops.instrumentation.common.attributes import AttributeMap
+from agentops.semconv import SpanAttributes, LLMRequestTypeValues
+
+logger = logging.getLogger(__name__)
+
+LLM_REQUEST_TYPE = LLMRequestTypeValues.EMBEDDING
+
+
+def handle_embeddings_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> AttributeMap:
+    """Extract attributes from embeddings calls."""
+    attributes = {
+        SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value,
+        SpanAttributes.LLM_SYSTEM: "OpenAI",
+    }
+
+    # Extract request attributes from kwargs
+    if kwargs:
+        # Model
+        if "model" in kwargs:
+            attributes[SpanAttributes.LLM_REQUEST_MODEL] = kwargs["model"]
+
+        # Headers
+        headers = kwargs.get("extra_headers") or kwargs.get("headers")
+        if headers:
+            attributes[SpanAttributes.LLM_REQUEST_HEADERS] = str(headers)
+
+        # Input
+        if should_send_prompts() and "input" in kwargs:
+            input_param = kwargs["input"]
+            if isinstance(input_param, str):
+                attributes[f"{SpanAttributes.LLM_PROMPTS}.0.content"] = input_param
+            elif isinstance(input_param, list):
+                for i, inp in enumerate(input_param):
+                    if isinstance(inp, str):
+                        attributes[f"{SpanAttributes.LLM_PROMPTS}.{i}.content"] = inp
+                    elif isinstance(inp, (int, list)):
+                        # Token inputs - convert to string representation
+                        attributes[f"{SpanAttributes.LLM_PROMPTS}.{i}.content"] = str(inp)
+
+    # Extract response attributes from return value
+    if return_value:
+        # Convert to dict if needed
+        response_dict = {}
+        if hasattr(return_value, "__dict__") and not hasattr(return_value, "__iter__"):
+            response_dict = model_as_dict(return_value)
+        elif isinstance(return_value, dict):
+            response_dict = return_value
+        elif hasattr(return_value, "model_dump"):
+            # Handle Pydantic models directly
+            response_dict = return_value.model_dump()
+        elif hasattr(return_value, "__dict__"):
+            # Try to use model_as_dict even if it has __iter__
+            response_dict = model_as_dict(return_value)
+        # Basic response attributes
+        if "model" in response_dict:
+            attributes[SpanAttributes.LLM_RESPONSE_MODEL] = response_dict["model"]
+
+        # Usage
+        usage = response_dict.get("usage", {})
+        if usage:
+            if is_openai_v1() and hasattr(usage, "__dict__"):
+                usage = usage.__dict__
+            if "total_tokens" in usage:
+                attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS] = usage["total_tokens"]
+            if "prompt_tokens" in usage:
+                attributes[SpanAttributes.LLM_USAGE_PROMPT_TOKENS] = usage["prompt_tokens"]
+
+        # Embeddings data
+        if should_send_prompts() and "data" in response_dict:
+            data = response_dict["data"]
+            for i, item in enumerate(data):
+                embedding = item.get("embedding", [])
+                if embedding:
+                    # We don't store the full embedding vector, just metadata
+                    attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{i}.embedding_length"] = len(embedding)
+
+    return attributes

agentops/instrumentation/providers/openai/wrappers/image_gen.py

@@ -0,0 +1,75 @@
+"""Image generation wrapper for OpenAI instrumentation.
+
+This module provides attribute extraction for OpenAI image generation API.
+"""
+
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+from agentops.instrumentation.providers.openai.wrappers.shared import model_as_dict
+from agentops.instrumentation.common.attributes import AttributeMap
+from agentops.semconv import SpanAttributes
+
+logger = logging.getLogger(__name__)
+
+
+def handle_image_gen_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> AttributeMap:
+    """Extract attributes from image generation calls."""
+    attributes = {
+        SpanAttributes.LLM_SYSTEM: "OpenAI",
+        "gen_ai.operation.name": "image_generation",
+    }
+
+    # Extract request attributes from kwargs
+    if kwargs:
+        # Model
+        if "model" in kwargs:
+            attributes[SpanAttributes.LLM_REQUEST_MODEL] = kwargs["model"]
+
+        # Image parameters
+        if "prompt" in kwargs:
+            attributes["gen_ai.request.image_prompt"] = kwargs["prompt"]
+        if "size" in kwargs:
+            attributes["gen_ai.request.image_size"] = kwargs["size"]
+        if "quality" in kwargs:
+            attributes["gen_ai.request.image_quality"] = kwargs["quality"]
+        if "style" in kwargs:
+            attributes["gen_ai.request.image_style"] = kwargs["style"]
+        if "n" in kwargs:
+            attributes["gen_ai.request.image_count"] = kwargs["n"]
+        if "response_format" in kwargs:
+            attributes["gen_ai.request.image_response_format"] = kwargs["response_format"]
+
+        # Headers
+        headers = kwargs.get("extra_headers") or kwargs.get("headers")
+        if headers:
+            attributes[SpanAttributes.LLM_REQUEST_HEADERS] = str(headers)
+
+    # Extract response attributes from return value
+    if return_value:
+        # Convert to dict if needed
+        response_dict = {}
+        if hasattr(return_value, "__dict__") and not hasattr(return_value, "__iter__"):
+            response_dict = model_as_dict(return_value)
+        elif isinstance(return_value, dict):
+            response_dict = return_value
+
+        # Response data
+        if "created" in response_dict:
+            attributes["gen_ai.response.created"] = response_dict["created"]
+
+        # Images data
+        if "data" in response_dict:
+            data = response_dict["data"]
+            attributes["gen_ai.response.image_count"] = len(data)
+
+            # We don't typically store the full image data, but we can store metadata
+            for i, item in enumerate(data):
+                if "revised_prompt" in item:
+                    attributes[f"gen_ai.response.images.{i}.revised_prompt"] = item["revised_prompt"]
+
+    return attributes

agentops/instrumentation/providers/openai/wrappers/responses.py

@@ -0,0 +1,191 @@
+"""Responses API wrapper for OpenAI instrumentation.
+
+This module provides attribute extraction for OpenAI Responses API endpoints.
+"""
+
+import json
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+from agentops.instrumentation.providers.openai.utils import is_openai_v1
+from agentops.instrumentation.providers.openai.wrappers.shared import (
+    model_as_dict,
+    should_send_prompts,
+)
+from agentops.instrumentation.common.attributes import AttributeMap
+from agentops.semconv import SpanAttributes, LLMRequestTypeValues
+
+logger = logging.getLogger(__name__)
+
+
+def handle_responses_attributes(
+    args: Optional[Tuple] = None,
+    kwargs: Optional[Dict] = None,
+    return_value: Optional[Any] = None,
+) -> AttributeMap:
+    """Extract attributes from responses API calls."""
+    attributes = {
+        SpanAttributes.LLM_SYSTEM: "OpenAI",
+        SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.CHAT.value,
+    }
+
+    # Extract request attributes from kwargs
+    if kwargs:
+        # Model
+        if "model" in kwargs:
+            attributes[SpanAttributes.LLM_REQUEST_MODEL] = kwargs["model"]
+
+        # Request parameters
+        if "max_tokens" in kwargs:
+            attributes[SpanAttributes.LLM_REQUEST_MAX_TOKENS] = kwargs["max_tokens"]
+        if "temperature" in kwargs:
+            attributes[SpanAttributes.LLM_REQUEST_TEMPERATURE] = kwargs["temperature"]
+        if "top_p" in kwargs:
+            attributes[SpanAttributes.LLM_REQUEST_TOP_P] = kwargs["top_p"]
+        if "frequency_penalty" in kwargs:
+            attributes[SpanAttributes.LLM_REQUEST_FREQUENCY_PENALTY] = kwargs["frequency_penalty"]
+        if "presence_penalty" in kwargs:
+            attributes[SpanAttributes.LLM_REQUEST_PRESENCE_PENALTY] = kwargs["presence_penalty"]
+        if "user" in kwargs:
+            attributes[SpanAttributes.LLM_USER] = kwargs["user"]
+
+        # Streaming
+        attributes[SpanAttributes.LLM_REQUEST_STREAMING] = kwargs.get("stream", False)
+
+        # Input messages
+        if should_send_prompts() and "input" in kwargs:
+            messages = kwargs["input"]
+            for i, msg in enumerate(messages):
+                prefix = f"{SpanAttributes.LLM_PROMPTS}.{i}"
+                if isinstance(msg, dict):
+                    if "role" in msg:
+                        attributes[f"{prefix}.role"] = msg["role"]
+                    if "content" in msg:
+                        content = msg["content"]
+                        if isinstance(content, list):
+                            content = json.dumps(content)
+                        attributes[f"{prefix}.content"] = content
+
+        # Tools
+        if "tools" in kwargs:
+            tools = kwargs["tools"]
+            if tools:
+                for i, tool in enumerate(tools):
+                    if isinstance(tool, dict) and "function" in tool:
+                        function = tool["function"]
+                        prefix = f"{SpanAttributes.LLM_REQUEST_FUNCTIONS}.{i}"
+                        if "name" in function:
+                            attributes[f"{prefix}.name"] = function["name"]
+                        if "description" in function:
+                            attributes[f"{prefix}.description"] = function["description"]
+                        if "parameters" in function:
+                            attributes[f"{prefix}.parameters"] = json.dumps(function["parameters"])
+
+    # Extract response attributes from return value
+    if return_value:
+        # Convert to dict if needed
+        response_dict = {}
+        if hasattr(return_value, "__dict__") and not hasattr(return_value, "__iter__"):
+            response_dict = model_as_dict(return_value)
+        elif isinstance(return_value, dict):
+            response_dict = return_value
+        elif hasattr(return_value, "model_dump"):
+            response_dict = return_value.model_dump()
+
+        # Basic response attributes
+        if "id" in response_dict:
+            attributes[SpanAttributes.LLM_RESPONSE_ID] = response_dict["id"]
+        if "model" in response_dict:
+            attributes[SpanAttributes.LLM_RESPONSE_MODEL] = response_dict["model"]
+
+        # Usage
+        usage = response_dict.get("usage", {})
+        if usage:
+            if is_openai_v1() and hasattr(usage, "__dict__"):
+                usage = usage.__dict__
+            if "total_tokens" in usage:
+                attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS] = usage["total_tokens"]
+            # Responses API uses input_tokens/output_tokens instead of prompt_tokens/completion_tokens
+            if "input_tokens" in usage:
+                attributes[SpanAttributes.LLM_USAGE_PROMPT_TOKENS] = usage["input_tokens"]
+            if "output_tokens" in usage:
+                attributes[SpanAttributes.LLM_USAGE_COMPLETION_TOKENS] = usage["output_tokens"]
+
+            # Reasoning tokens
+            output_details = usage.get("output_tokens_details", {})
+            if isinstance(output_details, dict) and "reasoning_tokens" in output_details:
+                attributes[SpanAttributes.LLM_USAGE_REASONING_TOKENS] = output_details["reasoning_tokens"]
+
+        # Output items
+        if should_send_prompts() and "output" in response_dict:
+            output_items = response_dict["output"]
+            completion_idx = 0
+            for i, output_item in enumerate(output_items):
+                # Handle dictionary format
+                if isinstance(output_item, dict):
+                    item_type = output_item.get("type")
+                # Handle object format (Pydantic models)
+                elif hasattr(output_item, "type"):
+                    item_type = output_item.type
+                    output_item_dict = model_as_dict(output_item)
+                    if output_item_dict and isinstance(output_item_dict, dict):
+                        output_item = output_item_dict
+                    else:
+                        continue
+                else:
+                    continue
+
+                if item_type == "message":
+                    # Extract message content
+                    if isinstance(output_item, dict):
+                        content = output_item.get("content", [])
+                        if isinstance(content, list):
+                            # Aggregate all text content
+                            text_parts = []
+                            for content_item in content:
+                                if isinstance(content_item, dict) and content_item.get("type") == "text":
+                                    text = content_item.get("text", "")
+                                    if text:
+                                        text_parts.append(text)
+                            if text_parts:
+                                full_text = "".join(text_parts)
+                                attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_idx}.content"] = full_text
+                                attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_idx}.role"] = "assistant"
+                                completion_idx += 1
+                        elif isinstance(content, str):
+                            # Simple string content
+                            attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_idx}.content"] = content
+                            attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_idx}.role"] = "assistant"
+                            completion_idx += 1
+
+                elif item_type == "function_call" and isinstance(output_item, dict):
+                    # Handle function calls
+                    # The arguments contain the actual response content for function calls
+                    args_str = output_item.get("arguments", "")
+                    if args_str:
+                        try:
+                            args = json.loads(args_str)
+                            # Extract reasoning if present (common in o3 models)
+                            reasoning = args.get("reasoning", "")
+                            if reasoning:
+                                attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_idx}.content"] = reasoning
+                                attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_idx}.role"] = "assistant"
+                                completion_idx += 1
+                        except json.JSONDecodeError:
+                            pass
+
+                    # Also store tool call details
+                    attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{i}.tool_calls.0.id"] = output_item.get("id", "")
+                    attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{i}.tool_calls.0.name"] = output_item.get("name", "")
+                    attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{i}.tool_calls.0.arguments"] = args_str
+
+                elif item_type == "reasoning" and isinstance(output_item, dict):
+                    # Handle reasoning items (o3 models provide these)
+                    summary = output_item.get("summary", "")
+                    if summary:
+                        attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_idx}.content"] = summary
+                        attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_idx}.role"] = "assistant"
+                        attributes[f"{SpanAttributes.LLM_COMPLETIONS}.{completion_idx}.type"] = "reasoning"
+                        completion_idx += 1
+
+    return attributes

agentops/instrumentation/providers/openai/wrappers/shared.py

@@ -0,0 +1,81 @@
+"""Shared utilities for OpenAI instrumentation wrappers.
+
+This module contains common functions and utilities used across different
+OpenAI API endpoint wrappers.
+"""
+
+import os
+import types
+import logging
+from typing import Any, Dict, Optional
+from importlib.metadata import version
+
+import openai
+from opentelemetry import context as context_api
+
+from agentops.instrumentation.providers.openai.utils import is_openai_v1
+
+logger = logging.getLogger(__name__)
+
+# Pydantic version for model serialization
+_PYDANTIC_VERSION = version("pydantic")
+
+# Cache for tiktoken encodings
+tiktoken_encodings = {}
+
+
+def should_send_prompts() -> bool:
+    """Check if prompt content should be sent in traces."""
+    return (os.getenv("TRACELOOP_TRACE_CONTENT") or "true").lower() == "true" or context_api.get_value(
+        "override_enable_content_tracing"
+    )
+
+
+def is_streaming_response(response: Any) -> bool:
+    """Check if a response is a streaming response."""
+    if is_openai_v1():
+        return isinstance(response, openai.Stream) or isinstance(response, openai.AsyncStream)
+    return isinstance(response, types.GeneratorType) or isinstance(response, types.AsyncGeneratorType)
+
+
+def model_as_dict(model: Any) -> Dict[str, Any]:
+    """Convert a model object to a dictionary."""
+    if model is None:
+        return {}
+    if isinstance(model, dict):
+        return model
+    if _PYDANTIC_VERSION < "2.0.0":
+        return model.dict()
+    if hasattr(model, "model_dump"):
+        return model.model_dump()
+    elif hasattr(model, "parse"):  # Raw API response
+        return model_as_dict(model.parse())
+    else:
+        return model if isinstance(model, dict) else {}
+
+
+def get_token_count_from_string(string: str, model_name: str) -> Optional[int]:
+    """Get token count from a string using tiktoken."""
+    from agentops.instrumentation.providers.openai.utils import should_record_stream_token_usage
+
+    if not should_record_stream_token_usage():
+        return None
+
+    try:
+        import tiktoken
+    except ImportError:
+        return None
+
+    if tiktoken_encodings.get(model_name) is None:
+        try:
+            encoding = tiktoken.encoding_for_model(model_name)
+        except KeyError as ex:
+            logger.warning(f"Failed to get tiktoken encoding for model_name {model_name}, error: {str(ex)}")
+            return None
+
+        tiktoken_encodings[model_name] = encoding
+    else:
+        encoding = tiktoken_encodings.get(model_name)
+
+    token_count = len(encoding.encode(string))
+    return token_count

agentops/instrumentation/utilities/concurrent_futures/__init__.py

@@ -0,0 +1,10 @@
+"""
+Instrumentation for concurrent.futures module.
+
+This module provides automatic instrumentation for ThreadPoolExecutor to ensure
+proper OpenTelemetry context propagation across thread boundaries.
+"""
+
+from .instrumentation import ConcurrentFuturesInstrumentor
+
+__all__ = ["ConcurrentFuturesInstrumentor"]

agentops/instrumentation/utilities/concurrent_futures/instrumentation.py

@@ -0,0 +1,206 @@
+"""
+OpenTelemetry Instrumentation for concurrent.futures module.
+
+This instrumentation automatically patches ThreadPoolExecutor to ensure proper
+context propagation across thread boundaries, preventing "NEW TRACE DETECTED" issues.
+"""
+
+import contextvars
+import functools
+from typing import Any, Callable, Collection, Optional, Tuple, TypeVar, List, Dict
+
+from concurrent.futures import ThreadPoolExecutor, Future
+
+from agentops.instrumentation.common import CommonInstrumentor, InstrumentorConfig
+from agentops.instrumentation.common.wrappers import WrapConfig
+from agentops.logging import logger
+
+# Store original methods to restore during uninstrumentation
+_original_init = None
+_original_submit = None
+
+# Type variables for better typing
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+def _context_propagating_init(original_init: Callable) -> Callable:
+    """Wrap ThreadPoolExecutor.__init__ to set up context-aware initializer."""
+
+    @functools.wraps(original_init)
+    def wrapped_init(
+        self: ThreadPoolExecutor,
+        max_workers: Optional[int] = None,
+        thread_name_prefix: str = "",
+        initializer: Optional[Callable] = None,
+        initargs: Tuple = (),
+    ) -> None:
+        # Capture the current context when the executor is created
+        main_context = contextvars.copy_context()
+
+        def context_aware_initializer() -> None:
+            """Initializer that sets up the captured context in each worker thread."""
+
+            # Set the main context variables in this thread
+            for var, value in main_context.items():
+                try:
+                    var.set(value)
+                except Exception as e:
+                    logger.debug(f"[ConcurrentFuturesInstrumentor] Could not set context var {var}: {e}")
+
+            # Run user's initializer if provided
+            if initializer and callable(initializer):
+                try:
+                    if initargs:
+                        initializer(*initargs)
+                    else:
+                        initializer()
+                except Exception as e:
+                    logger.error(f"[ConcurrentFuturesInstrumentor] Error in user initializer: {e}")
+                    raise
+
+        # Create executor with context-aware initializer
+        prefix = f"AgentOps-{thread_name_prefix}" if thread_name_prefix else "AgentOps-Thread"
+
+        # Call original init with our context-aware initializer
+        original_init(
+            self,
+            max_workers=max_workers,
+            thread_name_prefix=prefix,
+            initializer=context_aware_initializer,
+            initargs=(),  # We handle initargs in our wrapper
+        )
+
+    return wrapped_init
+
+
+def _context_propagating_submit(original_submit: Callable) -> Callable:
+    """Wrap ThreadPoolExecutor.submit to ensure context propagation."""
+
+    @functools.wraps(original_submit)
+    def wrapped_submit(self: ThreadPoolExecutor, func: Callable[..., R], *args: Any, **kwargs: Any) -> Future[R]:
+        # Log the submission
+        func_name = getattr(func, "__name__", str(func))  # noqa: F841
+
+        # The context propagation is handled by the initializer, so we can submit normally
+        # But we can add additional logging or monitoring here if needed
+        return original_submit(self, func, *args, **kwargs)
+
+    return wrapped_submit
+
+
+class ConcurrentFuturesInstrumentor(CommonInstrumentor):
+    """
+    Instrumentor for concurrent.futures module.
+
+    This instrumentor patches ThreadPoolExecutor to automatically propagate
+    OpenTelemetry context to worker threads, ensuring all LLM calls and other
+    instrumented operations maintain proper trace context.
+    """
+
+    def __init__(self):
+        """Initialize the concurrent.futures instrumentor."""
+        config = InstrumentorConfig(
+            library_name="agentops.instrumentation.concurrent_futures",
+            library_version="0.1.0",
+            wrapped_methods=[],  # We handle wrapping manually
+            metrics_enabled=False,  # No metrics needed for context propagation
+            dependencies=[],
+        )
+        super().__init__(config)
+        self._original_init = None
+        self._original_submit = None
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        """Return a list of instrumentation dependencies."""
+        return []
+
+    def _get_wrapped_methods(self) -> List[WrapConfig]:
+        """
+        Return list of methods to be wrapped.
+
+        For concurrent_futures, we don't use the standard wrapping mechanism
+        since we're patching methods directly for context propagation.
+        """
+        return []
+
+    def _create_metrics(self, meter) -> Dict[str, Any]:
+        """
+        Create metrics for this instrumentor.
+
+        This instrumentor doesn't need metrics as it's purely for context propagation.
+
+        Args:
+            meter: The meter instance (unused)
+
+        Returns:
+            Empty dict since no metrics are needed
+        """
+        return {}
+
+    def _instrument(self, **kwargs: Any) -> None:
+        """Instrument the concurrent.futures module."""
+        # Note: We don't call super()._instrument() here because we're not using
+        # the standard wrapping mechanism for this special instrumentor
+
+        logger.debug("[ConcurrentFuturesInstrumentor] Starting instrumentation")
+
+        # Store original methods
+        self._original_init = ThreadPoolExecutor.__init__
+        self._original_submit = ThreadPoolExecutor.submit
+
+        # Patch ThreadPoolExecutor methods
+        ThreadPoolExecutor.__init__ = _context_propagating_init(self._original_init)
+        ThreadPoolExecutor.submit = _context_propagating_submit(self._original_submit)
+
+        logger.info("[ConcurrentFuturesInstrumentor] Successfully instrumented concurrent.futures.ThreadPoolExecutor")
+
+    def _uninstrument(self, **kwargs: Any) -> None:
+        """Uninstrument the concurrent.futures module."""
+        # Note: We don't call super()._uninstrument() here because we're not using
+        # the standard wrapping mechanism for this special instrumentor
+
+        logger.debug("[ConcurrentFuturesInstrumentor] Starting uninstrumentation")
+
+        # Restore original methods
+        if self._original_init:
+            ThreadPoolExecutor.__init__ = self._original_init
+            self._original_init = None
+
+        if self._original_submit:
+            ThreadPoolExecutor.submit = self._original_submit
+            self._original_submit = None
+
+        logger.info("[ConcurrentFuturesInstrumentor] Successfully uninstrumented concurrent.futures.ThreadPoolExecutor")
+
+    @staticmethod
+    def instrument_module_directly() -> bool:
+        """
+        Directly instrument the module without using the standard instrumentor interface.
+
+        This can be called manually if automatic instrumentation is not desired.
+
+        Returns:
+            bool: True if instrumentation was applied, False if already instrumented
+        """
+        instrumentor = ConcurrentFuturesInstrumentor()
+        if not instrumentor.is_instrumented_by_opentelemetry:
+            instrumentor.instrument()
+            return True
+        return False
+
+    @staticmethod
+    def uninstrument_module_directly() -> bool:
+        """
+        Directly uninstrument the module.
+
+        This can be called manually to remove instrumentation.
+
+        Returns:
+            bool: True if uninstrumentation was applied, False if already uninstrumented
+        """
+        instrumentor = ConcurrentFuturesInstrumentor()
+        if instrumentor.is_instrumented_by_opentelemetry:
+            instrumentor.uninstrument()
+            return True
+        return False

agentops/integration/callbacks/dspy/__init__.py

@@ -0,0 +1,11 @@
+"""
+DSPy integration for AgentOps.
+
+This module provides the AgentOps DSPy integration, including callbacks and utilities.
+"""
+
+from agentops.integration.callbacks.dspy.callback import DSPyCallbackHandler
+
+__all__ = [
+    "DSPyCallbackHandler",
+]