mseep-agentops 0.4.18__py3-none-any.whl

agentops/logging/config.py

@@ -0,0 +1,86 @@
+import logging
+import os
+
+from agentops.logging.formatters import AgentOpsLogFileFormatter, AgentOpsLogFormatter
+
+# Create the logger at module level
+logger = logging.getLogger("agentops")
+logger.propagate = False
+logger.setLevel(logging.CRITICAL)
+
+
+def configure_logging(config=None):  # Remove type hint temporarily to avoid circular import
+    """Configure the AgentOps logger with console and optional file handlers.
+
+    Args:
+        config: Optional Config instance. If not provided, a new Config instance will be created.
+    """
+    # Defer the Config import to avoid circular dependency
+    if config is None:
+        from agentops.config import Config
+
+        config = Config()
+
+    # Use env var as override if present, otherwise use config
+    log_level_env = os.environ.get("AGENTOPS_LOG_LEVEL", "").upper()
+    if log_level_env and hasattr(logging, log_level_env):
+        log_level = getattr(logging, log_level_env)
+    else:
+        # Handle string log levels from config
+        if isinstance(config.log_level, str):
+            log_level_str = config.log_level.upper()
+            if hasattr(logging, log_level_str):
+                log_level = getattr(logging, log_level_str)
+            else:
+                log_level = logging.INFO
+        else:
+            log_level = config.log_level if isinstance(config.log_level, int) else logging.INFO
+
+    logger.setLevel(log_level)
+
+    # Remove existing handlers
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
+
+    # Configure console logging
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(log_level)
+    stream_handler.setFormatter(AgentOpsLogFormatter())
+    logger.addHandler(stream_handler)
+
+    # Configure file logging if enabled
+    log_to_file = os.environ.get("AGENTOPS_LOGGING_TO_FILE", "True").lower() == "true"
+    if log_to_file:
+        file_handler = logging.FileHandler("agentops.log", mode="w")
+        file_handler.setLevel(log_level)
+        formatter = AgentOpsLogFileFormatter("%(asctime)s - %(levelname)s - %(message)s")
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    return logger
+
+
+def intercept_opentelemetry_logging():
+    """
+    Configure OpenTelemetry logging to redirect all messages to the AgentOps logger.
+    All OpenTelemetry logs will be prefixed with [opentelemetry.X] and set to DEBUG level.
+    """
+    prefix = "opentelemetry"
+    otel_root_logger = logging.getLogger(prefix)
+    otel_root_logger.propagate = False
+    otel_root_logger.setLevel(logging.DEBUG)  # capture all
+
+    for handler in otel_root_logger.handlers[:]:
+        otel_root_logger.removeHandler(handler)
+
+    # Create a handler that forwards all messages to the AgentOps logger
+    class OtelLogHandler(logging.Handler):
+        def emit(self, record):
+            if record.name.startswith(f"{prefix}."):
+                module_name = record.name.replace(f"{prefix}.", "", 1)
+            else:
+                module_name = record.name
+            message = f"[{prefix}.{module_name}] {record.getMessage()}"
+            logger.debug(message)
+
+    otel_root_logger.addHandler(OtelLogHandler())

agentops/logging/formatters.py

@@ -0,0 +1,34 @@
+import logging
+import re
+
+
+class AgentOpsLogFormatter(logging.Formatter):
+    """Formatter for console logging with colors and prefix."""
+
+    blue = "\x1b[34m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    prefix = "🖇 AgentOps: "
+
+    FORMATS = {
+        logging.DEBUG: f"(DEBUG) {prefix}%(message)s",
+        logging.INFO: f"{prefix}%(message)s",
+        logging.WARNING: f"{prefix}%(message)s",
+        logging.ERROR: f"{bold_red}{prefix}%(message)s{reset}",
+        logging.CRITICAL: f"{bold_red}{prefix}%(message)s{reset}",
+    }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno, self.FORMATS[logging.INFO])
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+class AgentOpsLogFileFormatter(logging.Formatter):
+    """Formatter for file logging that removes ANSI escape codes."""
+
+    ANSI_ESCAPE_PATTERN = re.compile(r"\x1b\[[0-9;]*m")
+
+    def format(self, record):
+        record.msg = self.ANSI_ESCAPE_PATTERN.sub("", str(record.msg))
+        return super().format(record)

agentops/logging/instrument_logging.py

@@ -0,0 +1,91 @@
+import builtins
+import logging
+import atexit
+from typing import Any
+from io import StringIO
+
+_original_print = builtins.print
+
+# Global buffer to store logs
+_log_buffer = StringIO()
+
+
+def setup_print_logger() -> None:
+    """
+    Instruments the built-in print function and configures logging to use a memory buffer.
+    Preserves existing logging configuration and console output behavior.
+    """
+    buffer_logger = logging.getLogger("agentops_buffer_logger")
+    buffer_logger.setLevel(logging.DEBUG)
+
+    # Check if the logger already has handlers to prevent duplicates
+    if not buffer_logger.handlers:
+        # Create a StreamHandler that writes to our StringIO buffer
+        buffer_handler = logging.StreamHandler(_log_buffer)
+        buffer_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        buffer_handler.setLevel(logging.DEBUG)
+        buffer_logger.addHandler(buffer_handler)
+
+        # Ensure the new logger doesn't propagate to root
+        buffer_logger.propagate = False
+
+    def print_logger(*args: Any, **kwargs: Any) -> None:
+        """
+        Custom print function that logs to buffer and console.
+
+        Args:
+            *args: Arguments to print
+            **kwargs: Keyword arguments to print
+        """
+        message = " ".join(str(arg) for arg in args)
+        buffer_logger.info(message)
+
+        # print to console using original print
+        _original_print(*args, **kwargs)
+
+    # Only replace print if it hasn't been replaced already
+    if builtins.print is _original_print:
+        builtins.print = print_logger
+
+    def cleanup():
+        """
+        Cleanup function to be called when the process exits.
+        Restores the original print function and clears the buffer.
+        """
+        try:
+            # Remove our buffer handler
+            for handler in buffer_logger.handlers[:]:
+                handler.close()
+                buffer_logger.removeHandler(handler)
+
+            # Clear the buffer
+            _log_buffer.seek(0)
+            _log_buffer.truncate()
+
+            # Restore the original print function
+            builtins.print = _original_print
+        except Exception as e:
+            # If something goes wrong during cleanup, just print the error
+            _original_print(f"Error during cleanup: {e}")
+
+    # Register the cleanup function to run when the process exits
+    atexit.register(cleanup)
+
+
+def upload_logfile(trace_id: int) -> None:
+    """
+    Upload the log content from the memory buffer to the API.
+    """
+    from agentops import get_client
+
+    # Get the content from the buffer
+    log_content = _log_buffer.getvalue()
+    if not log_content:
+        return
+
+    client = get_client()
+    client.api.v4.upload_logfile(log_content, trace_id)
+
+    # Clear the buffer after upload
+    _log_buffer.seek(0)
+    _log_buffer.truncate()

agentops/sdk/__init__.py

@@ -0,0 +1,27 @@
+"""
+AgentOps SDK for tracing and monitoring AI agents.
+
+This module provides a high-level API for creating and managing spans
+for different types of operations in AI agent workflows.
+"""
+
+# Import decorators
+from agentops.sdk.decorators import agent, operation, session, task, workflow
+
+# from agentops.sdk.traced import TracedObject  # Merged into TracedObject
+from agentops.sdk.types import TracingConfig
+
+from opentelemetry.trace.status import StatusCode
+
+__all__ = [
+    # Core components
+    "TracingConfig",
+    # Decorators
+    "session",
+    "operation",
+    "agent",
+    "task",
+    "workflow",
+    # OpenTelemetry status codes
+    "StatusCode",
+]

agentops/sdk/attributes.py

@@ -0,0 +1,151 @@
+"""
+Attribute management for AgentOps SDK.
+
+This module contains functions that create attributes for various telemetry contexts,
+isolating the knowledge of semantic conventions from the core tracing logic.
+"""
+
+import platform
+import os
+from typing import Any, Optional, Union
+
+import psutil  #  type: ignore[import-untyped]
+
+from agentops.logging import logger
+from agentops.semconv import ResourceAttributes, SpanAttributes, CoreAttributes
+from agentops.helpers.system import get_imported_libraries
+
+
+def get_system_resource_attributes() -> dict[str, Any]:
+    """
+    Get system resource attributes for telemetry.
+
+    Returns:
+        dictionary containing system information attributes
+    """
+    attributes: dict[str, Any] = {
+        ResourceAttributes.HOST_MACHINE: platform.machine(),
+        ResourceAttributes.HOST_NAME: platform.node(),
+        ResourceAttributes.HOST_NODE: platform.node(),
+        ResourceAttributes.HOST_PROCESSOR: platform.processor(),
+        ResourceAttributes.HOST_SYSTEM: platform.system(),
+        ResourceAttributes.HOST_VERSION: platform.version(),
+        ResourceAttributes.HOST_OS_RELEASE: platform.release(),
+    }
+
+    # Add CPU stats
+    try:
+        attributes[ResourceAttributes.CPU_COUNT] = os.cpu_count() or 0
+        attributes[ResourceAttributes.CPU_PERCENT] = psutil.cpu_percent(interval=0.1)
+    except Exception as e:
+        logger.debug(f"Error getting CPU stats: {e}")
+
+    # Add memory stats
+    try:
+        memory = psutil.virtual_memory()
+        attributes[ResourceAttributes.MEMORY_TOTAL] = memory.total
+        attributes[ResourceAttributes.MEMORY_AVAILABLE] = memory.available
+        attributes[ResourceAttributes.MEMORY_USED] = memory.used
+        attributes[ResourceAttributes.MEMORY_PERCENT] = memory.percent
+    except Exception as e:
+        logger.debug(f"Error getting memory stats: {e}")
+
+    return attributes
+
+
+def get_global_resource_attributes(
+    service_name: str,
+    project_id: Optional[str] = None,
+) -> dict[str, Any]:
+    """
+    Get all global resource attributes for telemetry.
+
+    Combines service metadata and imported libraries into a complete
+    resource attributes dictionary.
+
+    Args:
+        service_name: Name of the service
+        project_id: Optional project ID
+
+    Returns:
+        dictionary containing all resource attributes
+    """
+    # Start with service attributes
+    attributes: dict[str, Any] = {
+        ResourceAttributes.SERVICE_NAME: service_name,
+    }
+
+    if project_id:
+        attributes[ResourceAttributes.PROJECT_ID] = project_id
+
+    if imported_libraries := get_imported_libraries():
+        attributes[ResourceAttributes.IMPORTED_LIBRARIES] = imported_libraries
+
+    return attributes
+
+
+def get_trace_attributes(tags: Optional[Union[dict[str, Any], list[str]]] = None) -> dict[str, Any]:
+    """
+    Get attributes for trace spans.
+
+    Args:
+        tags: Optional tags to include (dict or list)
+
+    Returns:
+        dictionary containing trace attributes
+    """
+    attributes: dict[str, Any] = {}
+
+    if tags:
+        if isinstance(tags, list):
+            attributes[CoreAttributes.TAGS] = tags
+        elif isinstance(tags, dict):
+            attributes.update(tags)  # Add dict tags directly
+        else:
+            logger.warning(f"Invalid tags format: {tags}. Must be list or dict.")
+
+    return attributes
+
+
+def get_span_attributes(
+    operation_name: str, span_kind: str, version: Optional[int] = None, **kwargs: Any
+) -> dict[str, Any]:
+    """
+    Get attributes for operation spans.
+
+    Args:
+        operation_name: Name of the operation being traced
+        span_kind: Type of operation (from SpanKind)
+        version: Optional version identifier for the operation
+        **kwargs: Additional attributes to include
+
+    Returns:
+        dictionary containing span attributes
+    """
+    attributes: dict[str, Any] = {
+        SpanAttributes.AGENTOPS_SPAN_KIND: span_kind,
+        SpanAttributes.OPERATION_NAME: operation_name,
+    }
+
+    if version is not None:
+        attributes[SpanAttributes.OPERATION_VERSION] = version
+
+    # Add any additional attributes passed as kwargs
+    attributes.update(kwargs)
+
+    return attributes
+
+
+def get_session_end_attributes(end_state: str) -> dict[str, Any]:
+    """
+    Get attributes for session ending.
+
+    Args:
+        end_state: The final state of the session
+
+    Returns:
+        dictionary containing session end attributes
+    """
+    return {
+        SpanAttributes.AGENTOPS_SESSION_END_STATE: end_state,
+    }