mseep-agentops 0.4.18__py3-none-any.whl

agentops/client/http/http_adapter.py

@@ -0,0 +1,116 @@
+from typing import Optional
+
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
+
+# from agentops.client.auth_manager import AuthManager
+
+
+class BaseHTTPAdapter(HTTPAdapter):
+    """Base HTTP adapter with enhanced connection pooling and retry logic"""
+
+    def __init__(
+        self,
+        pool_connections: int = 15,
+        pool_maxsize: int = 256,
+        max_retries: Optional[Retry] = None,
+    ):
+        """
+        Initialize the base HTTP adapter.
+
+        Args:
+            pool_connections: Number of connection pools to cache
+            pool_maxsize: Maximum number of connections to save in the pool
+            max_retries: Retry configuration for failed requests
+        """
+        if max_retries is None:
+            max_retries = Retry(
+                total=3,
+                backoff_factor=0.1,
+                status_forcelist=[500, 502, 503, 504],
+            )
+
+        super().__init__(pool_connections=pool_connections, pool_maxsize=pool_maxsize, max_retries=max_retries)
+
+
+# class AuthenticatedHttpAdapter(BaseHTTPAdapter):
+#     """HTTP adapter with automatic JWT authentication and refresh"""
+#
+#     def __init__(
+#         self,
+#         auth_manager: AuthManager,
+#         api_key: str,
+#         token_fetcher: Callable[[str], Union[str, AuthTokenResponse]],
+#         pool_connections: int = 15,
+#         pool_maxsize: int = 256,
+#         max_retries: Optional[Retry] = None,
+#     ):
+#         """
+#         Initialize the authenticated HTTP adapter.
+#
+#         Args:
+#             auth_manager: The authentication manager to use
+#             api_key: The API key to authenticate with
+#             token_fetcher: Function to fetch a new token if needed
+#             pool_connections: Number of connection pools to cache
+#             pool_maxsize: Maximum number of connections to save in the pool
+#             max_retries: Retry configuration for failed requests
+#         """
+#         self.auth_manager = auth_manager
+#         self.api_key = api_key
+#         self.token_fetcher = token_fetcher
+#
+#         super().__init__(
+#             pool_connections=pool_connections,
+#             pool_maxsize=pool_maxsize,
+#             max_retries=max_retries
+#         )
+#
+#     def add_headers(self, request, **kwargs):
+#         """Add authentication headers to the request"""
+#         # Get fresh auth headers from the auth manager
+#         self.auth_manager.maybe_fetch(self.api_key, self.token_fetcher)
+#         auth_headers = self.auth_manager.prepare_auth_headers(self.api_key)
+#
+#         # Update request headers
+#         for key, value in auth_headers.items():
+#             request.headers[key] = value
+#
+#         return request
+#
+#     def send(self, request, **kwargs):
+#         """Send the request with authentication retry logic"""
+#         # Ensure allow_redirects is set to False
+#         kwargs["allow_redirects"] = False
+#
+#         # Add auth headers to initial request
+#         request = self.add_headers(request, **kwargs)
+#
+#         # Make the initial request
+#         response = super().send(request, **kwargs)
+#
+#         # If we get a 401/403, check if it's due to token expiration
+#         if self.auth_manager.is_token_expired_response(response):
+#             logger.debug("Token expired, attempting to refresh")
+#             try:
+#                 # Force token refresh
+#                 self.auth_manager.clear_token()
+#                 self.auth_manager.maybe_fetch(self.api_key, self.token_fetcher)
+#
+#                 # Update request with new token
+#                 request = self.add_headers(request, **kwargs)
+#
+#                 # Retry the request
+#                 logger.debug("Retrying request with new token")
+#                 response = super().send(request, **kwargs)
+#             except AgentOpsApiJwtExpiredException as e:
+#                 # Authentication failed
+#                 logger.warning(f"Failed to refresh authentication token: {e}")
+#             except ApiServerException as e:
+#                 # Server error during token refresh
+#                 logger.error(f"Server error during token refresh: {e}")
+#             except Exception as e:
+#                 # Unexpected error during token refresh
+#                 logger.error(f"Unexpected error during token refresh: {e}")
+#
+#         return response

agentops/client/http/http_client.py

@@ -0,0 +1,215 @@
+from typing import Dict, Optional
+
+import requests
+
+from agentops.client.http.http_adapter import BaseHTTPAdapter
+from agentops.logging import logger
+from agentops.helpers.version import get_agentops_version
+
+
+class HttpClient:
+    """Base HTTP client with connection pooling and session management"""
+
+    _session: Optional[requests.Session] = None
+    _project_id: Optional[str] = None
+
+    @classmethod
+    def get_project_id(cls) -> Optional[str]:
+        """Get the stored project ID"""
+        return cls._project_id
+
+    @classmethod
+    def get_session(cls) -> requests.Session:
+        """Get or create the global session with optimized connection pooling"""
+        if cls._session is None:
+            cls._session = requests.Session()
+
+            # Configure connection pooling
+            adapter = BaseHTTPAdapter()
+
+            # Mount adapter for both HTTP and HTTPS
+            cls._session.mount("http://", adapter)
+            cls._session.mount("https://", adapter)
+
+            # Set default headers
+            cls._session.headers.update(
+                {
+                    "Connection": "keep-alive",
+                    "Keep-Alive": "timeout=10, max=1000",
+                    "Content-Type": "application/json",
+                    "User-Agent": f"agentops-python/{get_agentops_version() or 'unknown'}",
+                }
+            )
+            logger.debug(f"Agentops version: agentops-python/{get_agentops_version() or 'unknown'}")
+        return cls._session
+
+    # @classmethod
+    # def get_authenticated_session(
+    #     cls,
+    #     endpoint: str,
+    #     api_key: str,
+    #     token_fetcher: Optional[Callable[[str], str]] = None,
+    # ) -> requests.Session:
+    #     """
+    #     Create a new session with authentication handling.
+    #
+    #     Args:
+    #         endpoint: Base API endpoint (used to derive auth endpoint if needed)
+    #         api_key: The API key to use for authentication
+    #         token_fetcher: Optional custom token fetcher function
+    #
+    #     Returns:
+    #         A requests.Session with authentication handling
+    #     """
+    #     # Create auth manager with default token endpoint
+    #     auth_endpoint = f"{endpoint}/auth/token"
+    #     auth_manager = AuthManager(auth_endpoint)
+    #
+    #     # Use provided token fetcher or create a default one
+    #     if token_fetcher is None:
+    #         def default_token_fetcher(key: str) -> str:
+    #             # Simple token fetching implementation
+    #             try:
+    #                 response = requests.post(
+    #                     auth_manager.token_endpoint,
+    #                     json={"api_key": key},
+    #                     headers={"Content-Type": "application/json"},
+    #                     timeout=30
+    #                 )
+    #
+    #                 if response.status_code == 401 or response.status_code == 403:
+    #                     error_msg = "Invalid API key or unauthorized access"
+    #                     try:
+    #                         error_data = response.json()
+    #                         if "error" in error_data:
+    #                             error_msg = error_data["error"]
+    #                     except Exception:
+    #                         if response.text:
+    #                             error_msg = response.text
+    #
+    #                     logger.error(f"Authentication failed: {error_msg}")
+    #                     raise AgentOpsApiJwtExpiredException(f"Authentication failed: {error_msg}")
+    #
+    #                 if response.status_code >= 500:
+    #                     logger.error(f"Server error during authentication: {response.status_code}")
+    #                     raise ApiServerException(f"Server error during authentication: {response.status_code}")
+    #
+    #                 if response.status_code != 200:
+    #                     logger.error(f"Unexpected status code during authentication: {response.status_code}")
+    #                     raise AgentOpsApiJwtExpiredException(f"Failed to fetch token: {response.status_code}")
+    #
+    #                 token_data = response.json()
+    #                 if "token" not in token_data:
+    #                     logger.error("Token not found in response")
+    #                     raise AgentOpsApiJwtExpiredException("Token not found in response")
+    #
+    #                 # Store project_id if present in the response
+    #                 if "project_id" in token_data:
+    #                     HttpClient._project_id = token_data["project_id"]
+    #                     logger.debug(f"Project ID stored: {HttpClient._project_id} (will be set as {ResourceAttributes.PROJECT_ID})")
+    #
+    #                 return token_data["token"]
+    #             except requests.RequestException as e:
+    #                 logger.error(f"Network error during authentication: {e}")
+    #                 raise AgentOpsApiJwtExpiredException(f"Network error during authentication: {e}")
+    #
+    #         token_fetcher = default_token_fetcher
+    #
+    #     # Create a new session
+    #     session = requests.Session()
+    #
+    #     # Create an authenticated adapter
+    #     adapter = AuthenticatedHttpAdapter(
+    #         auth_manager=auth_manager,
+    #         api_key=api_key,
+    #         token_fetcher=token_fetcher
+    #     )
+    #
+    #     # Mount the adapter for both HTTP and HTTPS
+    #     session.mount("http://", adapter)
+    #     session.mount("https://", adapter)
+    #
+    #     # Set default headers
+    #     session.headers.update({
+    #         "Connection": "keep-alive",
+    #         "Keep-Alive": "timeout=10, max=1000",
+    #         "Content-Type": "application/json",
+    #     })
+    #
+    #     return session
+
+    @classmethod
+    def request(
+        cls,
+        method: str,
+        url: str,
+        data: Optional[Dict] = None,
+        headers: Optional[Dict] = None,
+        timeout: int = 30,
+        max_redirects: int = 5,
+    ) -> requests.Response:
+        """
+        Make a generic HTTP request
+
+        Args:
+            method: HTTP method (e.g., 'get', 'post', 'put', 'delete')
+            url: Full URL for the request
+            data: Request payload (for POST, PUT methods)
+            headers: Request headers
+            timeout: Request timeout in seconds
+            max_redirects: Maximum number of redirects to follow (default: 5)
+
+        Returns:
+            Response from the API
+
+        Raises:
+            requests.RequestException: If the request fails
+            ValueError: If the redirect limit is exceeded or an unsupported HTTP method is used
+        """
+        session = cls.get_session()
+        method = method.lower()
+        redirect_count = 0
+
+        while redirect_count <= max_redirects:
+            # Make the request with allow_redirects=False
+            if method == "get":
+                response = session.get(url, headers=headers, timeout=timeout, allow_redirects=False)
+            elif method == "post":
+                response = session.post(url, json=data, headers=headers, timeout=timeout, allow_redirects=False)
+            elif method == "put":
+                response = session.put(url, json=data, headers=headers, timeout=timeout, allow_redirects=False)
+            elif method == "delete":
+                response = session.delete(url, headers=headers, timeout=timeout, allow_redirects=False)
+            else:
+                raise ValueError(f"Unsupported HTTP method: {method}")
+
+            # Check if we got a redirect response
+            if response.status_code in (301, 302, 303, 307, 308):
+                redirect_count += 1
+
+                if redirect_count > max_redirects:
+                    raise ValueError(f"Exceeded maximum number of redirects ({max_redirects})")
+
+                # Get the new location
+                if "location" not in response.headers:
+                    # No location header, can't redirect
+                    return response
+
+                # Update URL to the redirect location
+                url = response.headers["location"]
+
+                # For 303 redirects, always use GET for the next request
+                if response.status_code == 303:
+                    method = "get"
+                    data = None
+
+                logger.debug(f"Following redirect ({redirect_count}/{max_redirects}) to: {url}")
+
+                # Continue the loop to make the next request
+                continue
+
+            # Not a redirect, return the response
+            return response
+
+        # This should never be reached due to the max_redirects check above
+        return response

agentops/config.py

@@ -0,0 +1,268 @@
+import json
+import logging
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import List, Optional, Set, TypedDict, Union
+from uuid import UUID
+
+from opentelemetry.sdk.trace import SpanProcessor
+from opentelemetry.sdk.trace.export import SpanExporter
+
+from agentops.exceptions import InvalidApiKeyException
+from agentops.helpers.env import get_env_bool, get_env_int, get_env_list
+from agentops.helpers.serialization import AgentOpsJSONEncoder
+
+
+class ConfigDict(TypedDict):
+    api_key: Optional[str]
+    endpoint: Optional[str]
+    app_url: Optional[str]
+    max_wait_time: Optional[int]
+    export_flush_interval: Optional[int]
+    max_queue_size: Optional[int]
+    default_tags: Optional[List[str]]
+    trace_name: Optional[str]
+    instrument_llm_calls: Optional[bool]
+    auto_start_session: Optional[bool]
+    auto_init: Optional[bool]
+    skip_auto_end_session: Optional[bool]
+    env_data_opt_out: Optional[bool]
+    log_level: Optional[Union[str, int]]
+    fail_safe: Optional[bool]
+    prefetch_jwt_token: Optional[bool]
+    log_session_replay_url: Optional[bool]
+
+
+@dataclass
+class Config:
+    api_key: Optional[str] = field(
+        default_factory=lambda: os.getenv("AGENTOPS_API_KEY"),
+        metadata={"description": "API key for authentication with AgentOps services"},
+    )
+
+    endpoint: str = field(
+        default_factory=lambda: os.getenv("AGENTOPS_API_ENDPOINT", "https://api.agentops.ai"),
+        metadata={"description": "Base URL for the AgentOps API"},
+    )
+
+    app_url: str = field(
+        default_factory=lambda: os.getenv("AGENTOPS_APP_URL", "https://app.agentops.ai"),
+        metadata={"description": "Dashboard URL for the AgentOps application"},
+    )
+
+    max_wait_time: int = field(
+        default_factory=lambda: get_env_int("AGENTOPS_MAX_WAIT_TIME", 5000),
+        metadata={"description": "Maximum time in milliseconds to wait for API responses"},
+    )
+
+    export_flush_interval: int = field(
+        default_factory=lambda: get_env_int("AGENTOPS_EXPORT_FLUSH_INTERVAL", 1000),
+        metadata={"description": "Time interval in milliseconds between automatic exports of telemetry data"},
+    )
+
+    max_queue_size: int = field(
+        default_factory=lambda: get_env_int("AGENTOPS_MAX_QUEUE_SIZE", 512),
+        metadata={"description": "Maximum number of events to queue before forcing a flush"},
+    )
+
+    default_tags: Set[str] = field(
+        default_factory=lambda: get_env_list("AGENTOPS_DEFAULT_TAGS"),
+        metadata={"description": "Default tags to apply to all sessions"},
+    )
+
+    trace_name: Optional[str] = field(
+        default_factory=lambda: os.getenv("AGENTOPS_TRACE_NAME"),
+        metadata={"description": "Default name for the trace/session"},
+    )
+
+    instrument_llm_calls: bool = field(
+        default_factory=lambda: get_env_bool("AGENTOPS_INSTRUMENT_LLM_CALLS", True),
+        metadata={"description": "Whether to automatically instrument and track LLM API calls"},
+    )
+
+    auto_start_session: bool = field(
+        default_factory=lambda: get_env_bool("AGENTOPS_AUTO_START_SESSION", True),
+        metadata={"description": "Whether to automatically start a session when initializing"},
+    )
+
+    auto_init: bool = field(
+        default_factory=lambda: get_env_bool("AGENTOPS_AUTO_INIT", True),
+        metadata={"description": "Whether to automatically initialize the client on import"},
+    )
+
+    skip_auto_end_session: bool = field(
+        default_factory=lambda: get_env_bool("AGENTOPS_SKIP_AUTO_END_SESSION", False),
+        metadata={"description": "Whether to skip automatically ending sessions on program exit"},
+    )
+
+    env_data_opt_out: bool = field(
+        default_factory=lambda: get_env_bool("AGENTOPS_ENV_DATA_OPT_OUT", False),
+        metadata={"description": "Whether to opt out of collecting environment data"},
+    )
+
+    log_level: Union[str, int] = field(
+        default_factory=lambda: os.getenv("AGENTOPS_LOG_LEVEL", "INFO"),
+        metadata={"description": "Logging level for AgentOps logs"},
+    )
+
+    fail_safe: bool = field(
+        default_factory=lambda: get_env_bool("AGENTOPS_FAIL_SAFE", False),
+        metadata={"description": "Whether to suppress errors and continue execution when possible"},
+    )
+
+    prefetch_jwt_token: bool = field(
+        default_factory=lambda: get_env_bool("AGENTOPS_PREFETCH_JWT_TOKEN", True),
+        metadata={"description": "Whether to prefetch JWT token during initialization"},
+    )
+
+    log_session_replay_url: bool = field(
+        default_factory=lambda: get_env_bool("AGENTOPS_LOG_SESSION_REPLAY_URL", True),
+        metadata={"description": "Whether to log session replay URLs to the console"},
+    )
+
+    exporter_endpoint: Optional[str] = field(
+        default_factory=lambda: os.getenv("AGENTOPS_EXPORTER_ENDPOINT", "https://otlp.agentops.ai/v1/traces"),
+        metadata={
+            "description": "Endpoint for the span exporter. When not provided, the default AgentOps endpoint will be used."
+        },
+    )
+
+    exporter: Optional[SpanExporter] = field(
+        default_factory=lambda: None, metadata={"description": "Custom span exporter for OpenTelemetry trace data"}
+    )
+
+    processor: Optional[SpanProcessor] = field(
+        default_factory=lambda: None, metadata={"description": "Custom span processor for OpenTelemetry trace data"}
+    )
+
+    def configure(
+        self,
+        api_key: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        app_url: Optional[str] = None,
+        max_wait_time: Optional[int] = None,
+        export_flush_interval: Optional[int] = None,
+        max_queue_size: Optional[int] = None,
+        default_tags: Optional[List[str]] = None,
+        trace_name: Optional[str] = None,
+        instrument_llm_calls: Optional[bool] = None,
+        auto_start_session: Optional[bool] = None,
+        auto_init: Optional[bool] = None,
+        skip_auto_end_session: Optional[bool] = None,
+        env_data_opt_out: Optional[bool] = None,
+        log_level: Optional[Union[str, int]] = None,
+        fail_safe: Optional[bool] = None,
+        prefetch_jwt_token: Optional[bool] = None,
+        log_session_replay_url: Optional[bool] = None,
+        exporter: Optional[SpanExporter] = None,
+        processor: Optional[SpanProcessor] = None,
+        exporter_endpoint: Optional[str] = None,
+    ):
+        """Configure settings from kwargs, validating where necessary"""
+        if api_key is not None:
+            self.api_key = api_key
+            if not TESTING:  # Allow setting dummy keys in tests
+                try:
+                    UUID(api_key)
+                except ValueError:
+                    raise InvalidApiKeyException(api_key, self.endpoint)
+
+        if endpoint is not None:
+            self.endpoint = endpoint
+
+        if app_url is not None:
+            self.app_url = app_url
+
+        if max_wait_time is not None:
+            self.max_wait_time = max_wait_time
+
+        if export_flush_interval is not None:
+            self.export_flush_interval = export_flush_interval
+
+        if max_queue_size is not None:
+            self.max_queue_size = max_queue_size
+
+        if default_tags is not None:
+            self.default_tags = set(default_tags)
+
+        if trace_name is not None:
+            self.trace_name = trace_name
+
+        if instrument_llm_calls is not None:
+            self.instrument_llm_calls = instrument_llm_calls
+
+        if auto_start_session is not None:
+            self.auto_start_session = auto_start_session
+
+        if auto_init is not None:
+            self.auto_init = auto_init
+
+        if skip_auto_end_session is not None:
+            self.skip_auto_end_session = skip_auto_end_session
+
+        if env_data_opt_out is not None:
+            self.env_data_opt_out = env_data_opt_out
+
+        if log_level is not None:
+            if isinstance(log_level, str):
+                log_level_str = log_level.upper()
+                if hasattr(logging, log_level_str):
+                    self.log_level = getattr(logging, log_level_str)
+                else:
+                    self.log_level = logging.INFO
+            else:
+                self.log_level = log_level
+
+        if fail_safe is not None:
+            self.fail_safe = fail_safe
+
+        if prefetch_jwt_token is not None:
+            self.prefetch_jwt_token = prefetch_jwt_token
+
+        if log_session_replay_url is not None:
+            self.log_session_replay_url = log_session_replay_url
+
+        if exporter is not None:
+            self.exporter = exporter
+
+        if processor is not None:
+            self.processor = processor
+
+        if exporter_endpoint is not None:
+            self.exporter_endpoint = exporter_endpoint
+        # else:
+        #     self.exporter_endpoint = self.endpoint
+
+    def dict(self):
+        """Return a dictionary representation of the config"""
+        return {
+            "api_key": self.api_key,
+            "endpoint": self.endpoint,
+            "app_url": self.app_url,
+            "max_wait_time": self.max_wait_time,
+            "export_flush_interval": self.export_flush_interval,
+            "max_queue_size": self.max_queue_size,
+            "default_tags": self.default_tags,
+            "trace_name": self.trace_name,
+            "instrument_llm_calls": self.instrument_llm_calls,
+            "auto_start_session": self.auto_start_session,
+            "auto_init": self.auto_init,
+            "skip_auto_end_session": self.skip_auto_end_session,
+            "env_data_opt_out": self.env_data_opt_out,
+            "log_level": self.log_level,
+            "fail_safe": self.fail_safe,
+            "prefetch_jwt_token": self.prefetch_jwt_token,
+            "log_session_replay_url": self.log_session_replay_url,
+            "exporter": self.exporter,
+            "processor": self.processor,
+            "exporter_endpoint": self.exporter_endpoint,
+        }
+
+    def json(self):
+        """Return a JSON representation of the config"""
+        return json.dumps(self.dict(), cls=AgentOpsJSONEncoder)
+
+
+# checks if pytest is imported
+TESTING = "pytest" in sys.modules

agentops/enums.py

@@ -0,0 +1,36 @@
+"""
+AgentOps enums for user-friendly API.
+
+This module provides simple enums that users can import from agentops
+without needing to know about OpenTelemetry internals.
+"""
+
+from enum import Enum
+from opentelemetry.trace.status import StatusCode
+
+
+class TraceState(Enum):
+    """
+    Enum for trace end states.
+
+    This provides a user-friendly interface that maps to OpenTelemetry StatusCode internally.
+    Users can simply use agentops.TraceState.SUCCESS instead of importing OpenTelemetry.
+    """
+
+    SUCCESS = StatusCode.OK
+    ERROR = StatusCode.ERROR
+    UNSET = StatusCode.UNSET
+
+    def __str__(self) -> str:
+        """Return the name for string representation."""
+        return self.name
+
+    def to_status_code(self) -> StatusCode:
+        """Convert to OpenTelemetry StatusCode."""
+        return self.value
+
+
+# For backward compatibility, also provide these as module-level constants
+SUCCESS = TraceState.SUCCESS
+ERROR = TraceState.ERROR
+UNSET = TraceState.UNSET

agentops/exceptions.py

@@ -0,0 +1,38 @@
+class MultiSessionException(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class NoSessionException(Exception):
+    def __init__(self, message="No session found"):
+        super().__init__(message)
+
+
+class NoApiKeyException(Exception):
+    def __init__(
+        self,
+        message="Could not initialize AgentOps client - API Key is missing."
+        + "\n\t    Find your API key at https://app.agentops.ai/settings/projects",
+    ):
+        super().__init__(message)
+
+
+class InvalidApiKeyException(Exception):
+    def __init__(self, api_key, endpoint):
+        message = f"API Key is invalid: {{{api_key}}}.\n\t    Find your API key at {endpoint}/settings/projects"
+        super().__init__(message)
+
+
+class ApiServerException(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class AgentOpsClientNotInitializedException(RuntimeError):
+    def __init__(self, message="AgentOps client must be initialized before using this feature"):
+        super().__init__(message)
+
+
+class AgentOpsApiJwtExpiredException(Exception):
+    def __init__(self, message="JWT token has expired"):
+        super().__init__(message)