Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI
Python agentagentopsagents-sdkaianthropicautogencost-estimationcrewaievalsevaluation-metricsgroqlangchainllmmistralollamaopenaiopenai-agents
import os
import logging
import pytest
from unittest.mock import patch, MagicMock, mock_open
from agentops.logging.config import configure_logging, intercept_opentelemetry_logging, logger
class TestConfigureLogging:
"""Test the configure_logging function"""
@pytest.fixture(autouse=True)
def setup_and_teardown(self):
"""Setup and teardown for each test"""
# Store original logger state
original_handlers = logger.handlers[:]
original_level = logger.level
yield
# Restore original logger state
for handler in logger.handlers[:]:
logger.removeHandler(handler)
for handler in original_handlers:
logger.addHandler(handler)
logger.setLevel(original_level)
def test_configure_logging_with_no_config(self):
"""Test configure_logging when no config is provided"""
with patch("agentops.config.Config") as mock_config_class:
mock_config = MagicMock()
mock_config.log_level = logging.INFO
mock_config_class.return_value = mock_config
result = configure_logging()
assert result == logger
assert logger.level == logging.INFO
assert len(logger.handlers) >= 1 # At least console handler
def test_configure_logging_with_config_object(self):
"""Test configure_logging with a provided config object"""
mock_config = MagicMock()
mock_config.log_level = logging.DEBUG
result = configure_logging(mock_config)
assert result == logger
assert logger.level == logging.DEBUG
def test_configure_logging_with_env_override(self):
"""Test configure_logging with environment variable override"""
with patch.dict(os.environ, {"AGENTOPS_LOG_LEVEL": "WARNING"}):
mock_config = MagicMock()
mock_config.log_level = logging.DEBUG
result = configure_logging(mock_config)
assert result == logger
assert logger.level == logging.WARNING
def test_configure_logging_with_invalid_env_level(self):
"""Test configure_logging with invalid environment log level"""
with patch.dict(os.environ, {"AGENTOPS_LOG_LEVEL": "INVALID_LEVEL"}):
mock_config = MagicMock()
mock_config.log_level = logging.DEBUG
result = configure_logging(mock_config)
assert result == logger
assert logger.level == logging.DEBUG # Falls back to config
def test_configure_logging_with_string_config_level(self):
"""Test configure_logging with string log level in config"""
mock_config = MagicMock()
mock_config.log_level = "ERROR"
result = configure_logging(mock_config)
assert result == logger
assert logger.level == logging.ERROR
def test_configure_logging_with_invalid_string_config_level(self):
"""Test configure_logging with invalid string log level in config"""
mock_config = MagicMock()
mock_config.log_level = "INVALID_LEVEL"
result = configure_logging(mock_config)
assert result == logger
assert logger.level == logging.INFO # Falls back to INFO
def test_configure_logging_with_non_string_int_config_level(self):
"""Test configure_logging with non-string, non-int log level in config"""
mock_config = MagicMock()
mock_config.log_level = None # Neither string nor int
result = configure_logging(mock_config)
assert result == logger
assert logger.level == logging.INFO # Falls back to INFO
def test_configure_logging_removes_existing_handlers(self):
"""Test that configure_logging removes existing handlers"""
# Add a dummy handler
dummy_handler = logging.StreamHandler()
logger.addHandler(dummy_handler)
assert len(logger.handlers) >= 1
mock_config = MagicMock()
mock_config.log_level = logging.INFO
configure_logging(mock_config)
# Check that the dummy handler was removed
assert dummy_handler not in logger.handlers
def test_configure_logging_creates_console_handler(self):
"""Test that configure_logging creates a console handler"""
mock_config = MagicMock()
mock_config.log_level = logging.INFO
configure_logging(mock_config)
# Check that we have at least one StreamHandler
stream_handlers = [h for h in logger.handlers if isinstance(h, logging.StreamHandler)]
assert len(stream_handlers) >= 1
@patch("builtins.open", new_callable=mock_open)
def test_configure_logging_with_file_logging_enabled(self, mock_file):
"""Test configure_logging with file logging enabled"""
with patch.dict(os.environ, {"AGENTOPS_LOGGING_TO_FILE": "true"}):
mock_config = MagicMock()
mock_config.log_level = logging.INFO
configure_logging(mock_config)
# Check that file handler was created
file_handlers = [h for h in logger.handlers if isinstance(h, logging.FileHandler)]
assert len(file_handlers) >= 1
# Check that open was called with the correct filename (path may be absolute)
mock_file.assert_called_once()
call_args = mock_file.call_args
assert call_args[0][0].endswith("agentops.log")
assert call_args[0][1] == "w"
def test_configure_logging_with_file_logging_disabled(self):
"""Test configure_logging with file logging disabled"""
with patch.dict(os.environ, {"AGENTOPS_LOGGING_TO_FILE": "false"}):
mock_config = MagicMock()
mock_config.log_level = logging.INFO
configure_logging(mock_config)
# Check that no file handler was created
file_handlers = [h for h in logger.handlers if isinstance(h, logging.FileHandler)]
assert len(file_handlers) == 0
def test_configure_logging_with_file_logging_case_insensitive(self):
"""Test configure_logging with file logging case insensitive"""
with patch.dict(os.environ, {"AGENTOPS_LOGGING_TO_FILE": "TRUE"}):
mock_config = MagicMock()
mock_config.log_level = logging.INFO
configure_logging(mock_config)
# Check that file handler was created
file_handlers = [h for h in logger.handlers if isinstance(h, logging.FileHandler)]
assert len(file_handlers) >= 1
def test_configure_logging_with_file_logging_default(self):
"""Test configure_logging with file logging default (no env var)"""
# Remove the env var if it exists
if "AGENTOPS_LOGGING_TO_FILE" in os.environ:
del os.environ["AGENTOPS_LOGGING_TO_FILE"]
with patch("builtins.open", new_callable=mock_open):
mock_config = MagicMock()
mock_config.log_level = logging.INFO
configure_logging(mock_config)
# Check that file handler was created (default is True)
file_handlers = [h for h in logger.handlers if isinstance(h, logging.FileHandler)]
assert len(file_handlers) >= 1
class TestInterceptOpenTelemetryLogging:
"""Test the intercept_opentelemetry_logging function"""
@pytest.fixture(autouse=True)
def setup_and_teardown(self):
"""Setup and teardown for each test"""
# Store original opentelemetry logger state
otel_logger = logging.getLogger("opentelemetry")
original_handlers = otel_logger.handlers[:]
original_level = otel_logger.level
original_propagate = otel_logger.propagate
yield
# Restore original opentelemetry logger state
for handler in otel_logger.handlers[:]:
otel_logger.removeHandler(handler)
for handler in original_handlers:
otel_logger.addHandler(handler)
otel_logger.setLevel(original_level)
otel_logger.propagate = original_propagate
def test_intercept_opentelemetry_logging_configures_logger(self):
"""Test that intercept_opentelemetry_logging configures the opentelemetry logger"""
intercept_opentelemetry_logging()
otel_logger = logging.getLogger("opentelemetry")
assert otel_logger.level == logging.DEBUG
assert not otel_logger.propagate
assert len(otel_logger.handlers) == 1
def test_intercept_opentelemetry_logging_removes_existing_handlers(self):
"""Test that intercept_opentelemetry_logging removes existing handlers"""
otel_logger = logging.getLogger("opentelemetry")
dummy_handler = logging.StreamHandler()
otel_logger.addHandler(dummy_handler)
intercept_opentelemetry_logging()
assert dummy_handler not in otel_logger.handlers
def test_intercept_opentelemetry_logging_creates_custom_handler(self):
"""Test that intercept_opentelemetry_logging creates a custom handler"""
intercept_opentelemetry_logging()
otel_logger = logging.getLogger("opentelemetry")
assert len(otel_logger.handlers) == 1
handler = otel_logger.handlers[0]
assert hasattr(handler, "emit")
def test_otel_log_handler_emit_with_opentelemetry_prefix(self):
"""Test the OtelLogHandler.emit method with opentelemetry prefix"""
intercept_opentelemetry_logging()
otel_logger = logging.getLogger("opentelemetry")
handler = otel_logger.handlers[0]
# Create a mock record with opentelemetry prefix
record = logging.LogRecord(
name="opentelemetry.trace",
level=logging.INFO,
pathname="",
lineno=0,
msg="Test message",
args=(),
exc_info=None,
)
with patch.object(logger, "debug") as mock_debug:
handler.emit(record)
mock_debug.assert_called_once_with("[opentelemetry.trace] Test message")
def test_otel_log_handler_emit_without_opentelemetry_prefix(self):
"""Test the OtelLogHandler.emit method without opentelemetry prefix"""
intercept_opentelemetry_logging()
otel_logger = logging.getLogger("opentelemetry")
handler = otel_logger.handlers[0]
# Create a mock record without opentelemetry prefix
record = logging.LogRecord(
name="some.other.module",
level=logging.INFO,
pathname="",
lineno=0,
msg="Test message",
args=(),
exc_info=None,
)
with patch.object(logger, "debug") as mock_debug:
handler.emit(record)
mock_debug.assert_called_once_with("[opentelemetry.some.other.module] Test message")
def test_otel_log_handler_emit_with_exact_opentelemetry_name(self):
"""Test the OtelLogHandler.emit method with exact 'opentelemetry' name"""
intercept_opentelemetry_logging()
otel_logger = logging.getLogger("opentelemetry")
handler = otel_logger.handlers[0]
# Create a mock record with exact 'opentelemetry' name
record = logging.LogRecord(
name="opentelemetry", level=logging.INFO, pathname="", lineno=0, msg="Test message", args=(), exc_info=None
)
with patch.object(logger, "debug") as mock_debug:
handler.emit(record)
mock_debug.assert_called_once_with("[opentelemetry.opentelemetry] Test message")
class TestLoggerInitialization:
"""Test the logger initialization at module level"""
def test_logger_initialization(self):
"""Test that the logger is properly initialized"""
assert logger.name == "agentops"
assert not logger.propagate
assert logger.level == logging.CRITICAL # Default level