307 lines
12 KiB
Python
307 lines
12 KiB
Python
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
|