feat: Add ConfigHealthMonitor for automated crawler configuration health monitoring
Implement a comprehensive health monitoring system for crawler configurations that automatically detects failures and applies resolution strategies. Features - **Continuous Health Monitoring**: Periodic health checks for multiple crawler configurations with configurable check intervals - **Automatic Failure Detection**: Detects failures based on HTTP status codes, empty HTML responses, and logger errors - **Resolution Strategies**: Built-in and custom resolution strategies that automatically attempt to fix failing configurations - **Resolution Chains**: Support for sequential resolution strategies that validate each step before proceeding - **Metrics Collection**: Comprehensive metrics tracking including success rates, response times, resolution attempts, and uptime statistics - **Graceful Shutdown**: Robust cleanup mechanism that waits for active health checks to complete before shutting down - **Error Tracking**: Integrated logger error tracking to detect non-critical errors that don't fail HTTP requests but indicate issues Implementation Details - New module `crawl4ai/config_health_monitor.py` containing: - `ConfigHealthMonitor`: Main monitoring class - `ConfigHealthState`: Health state tracking dataclass - `ResolutionResult`: Resolution strategy result dataclass - `ResolutionStrategy`: Type alias for resolution callables - `_ErrorTrackingLogger`: Proxy logger for error event tracking - Key capabilities: - Register/unregister configurations for monitoring - Manual and automatic health checks - Config-specific or global resolution strategies - Thread-safe state management with asyncio locks - Per-config and global metrics reporting - Context manager support for automatic cleanup Testing - Comprehensive test suite in `tests/general/test_config_health_monitor.py`: - Basic functionality tests (initialization, registration) - Lifecycle management tests (start/stop, context manager) - Health checking tests (success/failure scenarios) - Resolution strategy tests - Metrics and status query tests - Property validation tests Examples - Example usage in `docs/examples/config_health_monitor_example.py`: - Demonstrates monitor initialization and configuration - Shows custom resolution strategies (incremental backoff, magic mode toggle) - Implements resolution chains with validation - Displays metrics reporting and status monitoring - Includes context manager usage pattern Technical Notes - Uses `copy.deepcopy()` for safe configuration mutation - Implements `_ErrorTrackingLogger` to capture logger errors during health checks - Tracks active health check tasks for graceful shutdown - Uses `CacheMode.BYPASS` for health check configs to ensure fresh data - Minimum check interval enforced at 10 seconds This feature enables production-grade monitoring of crawler configurations, automatically detecting and resolving issues before they impact crawling operations.
This commit is contained in:
Soham Kukreti
1072
crawl4ai/config_health_monitor.py
Normal file
1072
crawl4ai/config_health_monitor.py
Normal file
File diff suppressed because it is too large
Load Diff
378
docs/examples/config_health_monitor_example.py
Normal file
378
docs/examples/config_health_monitor_example.py
Normal file
@@ -0,0 +1,378 @@
|
||||
"""
|
||||
Example: Using ConfigHealthMonitor for Crawler Configuration Health Monitoring
|
||||
|
||||
This example demonstrates how to:
|
||||
1. Initialize a ConfigHealthMonitor
|
||||
2. Register multiple crawler configurations
|
||||
3. Set up custom resolution strategies
|
||||
4. Monitor health status and metrics
|
||||
5. Handle configuration failures automatically
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import copy
|
||||
from crawl4ai.config_health_monitor import ConfigHealthMonitor, ResolutionResult, ConfigHealthState
|
||||
from crawl4ai import BrowserConfig, CrawlerRunConfig
|
||||
from crawl4ai.async_configs import CacheMode
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Custom Resolution Strategies
|
||||
# ============================================================================
|
||||
|
||||
async def incremental_backoff_strategy(
|
||||
state: ConfigHealthState,
|
||||
monitor: ConfigHealthMonitor
|
||||
) -> ResolutionResult:
|
||||
"""
|
||||
Increase timeouts progressively when health checks fail.
|
||||
"""
|
||||
print(f" Applying incremental backoff for '{state.config_id}'...")
|
||||
|
||||
new_config = copy.deepcopy(state.config)
|
||||
|
||||
# Increase timeouts by 100%
|
||||
new_config.page_timeout = int(state.config.page_timeout * 2)
|
||||
if state.config.delay_before_return_html:
|
||||
new_config.delay_before_return_html = state.config.delay_before_return_html + 2.0
|
||||
|
||||
print(f" -> Increased page_timeout to {new_config.page_timeout}ms")
|
||||
|
||||
return ResolutionResult(
|
||||
success=True,
|
||||
action="timeout_increased",
|
||||
modified_config=new_config,
|
||||
metadata={
|
||||
"old_timeout": state.config.page_timeout,
|
||||
"new_timeout": new_config.page_timeout
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
async def toggle_magic_mode_strategy(
|
||||
state: ConfigHealthState,
|
||||
monitor: ConfigHealthMonitor
|
||||
) -> ResolutionResult:
|
||||
"""
|
||||
Enable/disable magic mode for anti-bot handling.
|
||||
"""
|
||||
print(f" Toggling magic mode for '{state.config_id}'...")
|
||||
|
||||
new_config = copy.deepcopy(state.config)
|
||||
new_config.magic = not state.config.magic
|
||||
|
||||
action = f"magic_{'enabled' if new_config.magic else 'disabled'}"
|
||||
print(f" -> Magic mode now: {new_config.magic}")
|
||||
|
||||
return ResolutionResult(
|
||||
success=True,
|
||||
action=action,
|
||||
modified_config=new_config
|
||||
)
|
||||
|
||||
|
||||
async def log_and_alert_strategy(
|
||||
state: ConfigHealthState,
|
||||
monitor: ConfigHealthMonitor
|
||||
) -> ResolutionResult:
|
||||
"""
|
||||
Log failure and send alert (in production, this would send to monitoring system).
|
||||
"""
|
||||
print(f" ALERT: Config '{state.config_id}' has failed!")
|
||||
print(f" → Error: {state.last_error}")
|
||||
print(f" → Consecutive failures: {state.consecutive_failures}")
|
||||
print(f" → Resolution attempts: {state.resolution_attempts}")
|
||||
|
||||
# In production, send to Slack, email, PagerDuty, etc.
|
||||
# await send_slack_alert(state)
|
||||
# await send_email_alert(state)
|
||||
|
||||
return ResolutionResult(
|
||||
success=False,
|
||||
action="alerted",
|
||||
metadata={"alert_sent": True}
|
||||
)
|
||||
|
||||
|
||||
def create_resolution_chain(strategies):
|
||||
"""
|
||||
Create a resolution chain that tries strategies sequentially.
|
||||
|
||||
After each successful strategy we immediately run a health check. If the
|
||||
check still fails, we continue to the next strategy until one succeeds or
|
||||
we exhaust the chain.
|
||||
"""
|
||||
async def chained_strategy(
|
||||
state: ConfigHealthState,
|
||||
monitor: ConfigHealthMonitor
|
||||
) -> ResolutionResult:
|
||||
if not strategies:
|
||||
return ResolutionResult(success=False, action="no_strategies_configured")
|
||||
|
||||
print(f"\nStarting resolution chain for '{state.config_id}'")
|
||||
|
||||
steps_metadata = []
|
||||
|
||||
for i, strategy in enumerate(strategies, 1):
|
||||
print(f"\n Step {i}/{len(strategies)}: {strategy.__name__}")
|
||||
result = await strategy(state, monitor)
|
||||
steps_metadata.append({
|
||||
"step": i,
|
||||
"strategy": strategy.__name__,
|
||||
"success": result.success,
|
||||
"action": result.action,
|
||||
"metadata": result.metadata
|
||||
})
|
||||
|
||||
if result.success:
|
||||
action_label = result.action or strategy.__name__
|
||||
print(f" Resolution applied: {action_label}")
|
||||
|
||||
if result.modified_config:
|
||||
state.config = result.modified_config
|
||||
|
||||
print(" Running validation health check...")
|
||||
try:
|
||||
validation_passed = await monitor._perform_health_check(state)
|
||||
except Exception as exc:
|
||||
print(f" Validation error: {exc}")
|
||||
validation_passed = False
|
||||
|
||||
steps_metadata[-1]["validation_passed"] = validation_passed
|
||||
|
||||
if validation_passed:
|
||||
print(" Validation succeeded. Resolution chain complete.")
|
||||
return ResolutionResult(
|
||||
success=True,
|
||||
action=action_label,
|
||||
modified_config=state.config,
|
||||
metadata={"steps": steps_metadata}
|
||||
)
|
||||
|
||||
print(" Validation failed. Trying next strategy...")
|
||||
else:
|
||||
print(f" Resolution failed: {result.action}")
|
||||
|
||||
print(f"\n All resolution strategies failed")
|
||||
return ResolutionResult(
|
||||
success=False,
|
||||
action="all_strategies_failed",
|
||||
metadata={"steps": steps_metadata}
|
||||
)
|
||||
|
||||
return chained_strategy
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Main Example
|
||||
# ============================================================================
|
||||
|
||||
async def main():
|
||||
print("=" * 70)
|
||||
print("ConfigHealthMonitor Example")
|
||||
print("=" * 70)
|
||||
|
||||
# Initialize monitor
|
||||
print("\nInitializing ConfigHealthMonitor...")
|
||||
monitor = ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(
|
||||
headless=True,
|
||||
verbose=False
|
||||
),
|
||||
check_interval=15.0, # Check every 15 seconds
|
||||
failure_threshold=2, # Trigger resolution after 2 failures
|
||||
resolution_retry_limit=2, # Try resolution twice max
|
||||
enable_metrics=True
|
||||
)
|
||||
|
||||
await monitor.start()
|
||||
print(f" Monitor started (check_interval={monitor.check_interval}s)")
|
||||
|
||||
# ========================================================================
|
||||
# Register Configurations
|
||||
# ========================================================================
|
||||
|
||||
print("\nRegistering configurations...")
|
||||
|
||||
# Config 1: Reliable website (should stay healthy)
|
||||
config_1_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(
|
||||
page_timeout=30000,
|
||||
cache_mode=CacheMode.BYPASS,
|
||||
magic=True,
|
||||
),
|
||||
test_url="https://www.olly.com/",
|
||||
config_id="olly_scraper",
|
||||
resolution_strategy=create_resolution_chain([
|
||||
toggle_magic_mode_strategy,
|
||||
])
|
||||
)
|
||||
print(f" Registered: {config_1_id} with resolution chain")
|
||||
|
||||
# Config 2: Another reliable website
|
||||
config_2_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(
|
||||
page_timeout=20000,
|
||||
magic=True,
|
||||
),
|
||||
test_url="https://example.com",
|
||||
config_id="example_scraper"
|
||||
)
|
||||
print(f" Registered: {config_2_id}")
|
||||
|
||||
# Config 3: Intentionally problematic (very short timeout)
|
||||
# This will trigger resolution strategies
|
||||
config_3_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(
|
||||
page_timeout=100, # 100ms - will likely timeout
|
||||
cache_mode=CacheMode.BYPASS,
|
||||
),
|
||||
test_url="https://httpbin.org/delay/5", # Delays response by 5 seconds
|
||||
config_id="impossible_scraper",
|
||||
resolution_strategy=create_resolution_chain([
|
||||
incremental_backoff_strategy,
|
||||
toggle_magic_mode_strategy,
|
||||
log_and_alert_strategy
|
||||
])
|
||||
)
|
||||
print(f" Registered: {config_3_id} (with resolution chain)")
|
||||
|
||||
print(f"\n Total configs registered: {monitor.registered_count}")
|
||||
|
||||
# ========================================================================
|
||||
# Perform Manual Health Checks
|
||||
# ========================================================================
|
||||
|
||||
print("\nPerforming initial health checks...")
|
||||
|
||||
for config_id in [config_1_id, config_2_id, config_3_id]:
|
||||
is_healthy = await monitor.check_health(config_id)
|
||||
status = monitor.get_health_status(config_id)
|
||||
|
||||
status_label = "healthy" if is_healthy else "unhealthy"
|
||||
print(f" {config_id}: {status.status} ({status_label})")
|
||||
if not is_healthy:
|
||||
print(f" Error: {status.last_error}")
|
||||
|
||||
# ========================================================================
|
||||
# Monitor for a Period
|
||||
# ========================================================================
|
||||
|
||||
print("\nMonitoring for 60 seconds (background loop running)...")
|
||||
print(" The monitor will automatically check all configs every 15s")
|
||||
print(" and apply resolution strategies when failures are detected.\n")
|
||||
|
||||
# Check status every 20 seconds
|
||||
for i in range(3):
|
||||
await asyncio.sleep(20)
|
||||
|
||||
print(f"\nStatus Check #{i+1}")
|
||||
print("-" * 70)
|
||||
|
||||
all_statuses = monitor.get_health_status()
|
||||
|
||||
for config_id, state in all_statuses.items():
|
||||
# Status emoji
|
||||
print(f"\n{config_id}")
|
||||
print(f" Status: {state.status}")
|
||||
print(f" Consecutive failures: {state.consecutive_failures}")
|
||||
print(f" Consecutive successes: {state.consecutive_successes}")
|
||||
print(f" Resolution attempts: {state.resolution_attempts}")
|
||||
|
||||
if state.last_check_time:
|
||||
print(f" Last checked: {state.last_check_time.strftime('%H:%M:%S')}")
|
||||
if state.last_success_time:
|
||||
print(f" Last success: {state.last_success_time.strftime('%H:%M:%S')}")
|
||||
if state.last_error:
|
||||
print(f" Last error: {state.last_error[:100]}...")
|
||||
|
||||
# ========================================================================
|
||||
# Final Metrics Report
|
||||
# ========================================================================
|
||||
|
||||
print("\n" + "=" * 70)
|
||||
print("Final Metrics Report")
|
||||
print("=" * 70)
|
||||
|
||||
metrics = monitor.get_metrics()
|
||||
|
||||
# Global metrics
|
||||
print("\nGlobal Metrics:")
|
||||
print(f" Total checks: {metrics['total_checks']}")
|
||||
print(f" Successful checks: {metrics['successful_checks']}")
|
||||
print(f" Failed checks: {metrics['failed_checks']}")
|
||||
print(f" Success rate: {metrics['success_rate']:.1%}")
|
||||
print(f" Total resolutions: {metrics['total_resolutions']}")
|
||||
print(f" Successful resolutions: {metrics['successful_resolutions']}")
|
||||
if metrics['total_resolutions'] > 0:
|
||||
print(f" Resolution success rate: {metrics['resolution_success_rate']:.1%}")
|
||||
print(f" Uptime: {metrics['uptime_seconds']:.1f}s")
|
||||
|
||||
# Per-config metrics
|
||||
print("\nPer-Config Metrics:")
|
||||
for config_id, config_metrics in metrics['configs'].items():
|
||||
print(f"\n {config_id}:")
|
||||
print(f" Status: {config_metrics['status']}")
|
||||
print(f" Uptime: {config_metrics['uptime_percent']:.1f}%")
|
||||
print(f" Avg response time: {config_metrics['avg_response_time']:.3f}s")
|
||||
print(f" Total checks: {config_metrics['total_checks']}")
|
||||
print(f" Successful: {config_metrics['successful_checks']}")
|
||||
print(f" Failed: {config_metrics['failed_checks']}")
|
||||
print(f" Resolution attempts: {config_metrics['resolution_attempts']}")
|
||||
|
||||
# ========================================================================
|
||||
# Cleanup
|
||||
# ========================================================================
|
||||
|
||||
print("\nStopping monitor...")
|
||||
await monitor.stop()
|
||||
print(" Monitor stopped successfully")
|
||||
|
||||
print("\n" + "=" * 70)
|
||||
print("Example completed!")
|
||||
print("=" * 70)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Alternative: Using Context Manager
|
||||
# ============================================================================
|
||||
|
||||
async def example_with_context_manager():
|
||||
"""
|
||||
Simplified example using context manager for automatic cleanup.
|
||||
"""
|
||||
print("\nExample: Using Context Manager\n")
|
||||
|
||||
async with ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False),
|
||||
check_interval=30.0,
|
||||
failure_threshold=3
|
||||
) as monitor:
|
||||
|
||||
# Register configs
|
||||
monitor.register_config(
|
||||
config=CrawlerRunConfig(page_timeout=30000),
|
||||
test_url="https://httpbin.org/html",
|
||||
config_id="example"
|
||||
)
|
||||
|
||||
# Monitor automatically runs in background
|
||||
print("Monitor running...")
|
||||
await asyncio.sleep(10)
|
||||
|
||||
# Get status
|
||||
status = monitor.get_health_status("example")
|
||||
print(f"Status: {status.status}")
|
||||
|
||||
# Context manager automatically stops on exit
|
||||
|
||||
print("Monitor automatically stopped")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Run main example
|
||||
asyncio.run(main())
|
||||
|
||||
# Uncomment to run context manager example
|
||||
# asyncio.run(example_with_context_manager())
|
||||
|
||||
455
tests/general/test_config_health_monitor.py
Normal file
455
tests/general/test_config_health_monitor.py
Normal file
@@ -0,0 +1,455 @@
|
||||
"""
|
||||
Tests for ConfigHealthMonitor class.
|
||||
|
||||
This test suite validates the health monitoring functionality for crawler configurations.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
import asyncio
|
||||
from crawl4ai.config_health_monitor import ConfigHealthMonitor, ResolutionResult, ConfigHealthState
|
||||
from crawl4ai import BrowserConfig, CrawlerRunConfig
|
||||
|
||||
|
||||
class TestConfigHealthMonitorBasic:
|
||||
"""Basic functionality tests for ConfigHealthMonitor."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_initialization(self):
|
||||
"""Test monitor initialization with default settings."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
assert monitor.check_interval >= 10.0 # Minimum enforced
|
||||
assert monitor.failure_threshold >= 1
|
||||
assert monitor.resolution_retry_limit >= 0
|
||||
assert monitor.registered_count == 0
|
||||
assert not monitor.is_running
|
||||
assert monitor.uptime is None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_initialization_with_config(self):
|
||||
"""Test monitor initialization with custom configuration."""
|
||||
browser_config = BrowserConfig(headless=True, verbose=False)
|
||||
|
||||
monitor = ConfigHealthMonitor(
|
||||
browser_config=browser_config,
|
||||
check_interval=30.0,
|
||||
failure_threshold=2,
|
||||
resolution_retry_limit=3,
|
||||
enable_metrics=True
|
||||
)
|
||||
|
||||
assert monitor.check_interval == 30.0
|
||||
assert monitor.failure_threshold == 2
|
||||
assert monitor.resolution_retry_limit == 3
|
||||
assert monitor.enable_metrics is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_register_config(self):
|
||||
"""Test registering a configuration."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
config = CrawlerRunConfig(page_timeout=30000)
|
||||
config_id = monitor.register_config(
|
||||
config=config,
|
||||
test_url="https://example.com",
|
||||
config_id="test_config"
|
||||
)
|
||||
|
||||
assert config_id == "test_config"
|
||||
assert monitor.registered_count == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_register_config_auto_id(self):
|
||||
"""Test registering a configuration with auto-generated ID."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
config = CrawlerRunConfig(page_timeout=30000)
|
||||
config_id = monitor.register_config(
|
||||
config=config,
|
||||
test_url="https://example.com"
|
||||
)
|
||||
|
||||
assert config_id.startswith("config_")
|
||||
assert monitor.registered_count == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_register_duplicate_config_id(self):
|
||||
"""Test that duplicate config IDs raise an error."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
config = CrawlerRunConfig(page_timeout=30000)
|
||||
monitor.register_config(
|
||||
config=config,
|
||||
test_url="https://example.com",
|
||||
config_id="duplicate"
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError, match="already registered"):
|
||||
monitor.register_config(
|
||||
config=config,
|
||||
test_url="https://example.com",
|
||||
config_id="duplicate"
|
||||
)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_register_empty_url(self):
|
||||
"""Test that empty test URLs raise an error."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
config = CrawlerRunConfig()
|
||||
|
||||
with pytest.raises(ValueError, match="cannot be empty"):
|
||||
monitor.register_config(
|
||||
config=config,
|
||||
test_url=""
|
||||
)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_unregister_config(self):
|
||||
"""Test unregistering a configuration."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
config = CrawlerRunConfig()
|
||||
config_id = monitor.register_config(
|
||||
config=config,
|
||||
test_url="https://example.com",
|
||||
config_id="to_remove"
|
||||
)
|
||||
|
||||
assert monitor.registered_count == 1
|
||||
|
||||
result = monitor.unregister_config(config_id)
|
||||
assert result is True
|
||||
assert monitor.registered_count == 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_unregister_nonexistent_config(self):
|
||||
"""Test unregistering a non-existent configuration."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
result = monitor.unregister_config("nonexistent")
|
||||
assert result is False
|
||||
|
||||
|
||||
class TestConfigHealthMonitorLifecycle:
|
||||
"""Lifecycle management tests."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_start_stop(self):
|
||||
"""Test monitor start and stop."""
|
||||
monitor = ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False)
|
||||
)
|
||||
|
||||
assert not monitor.is_running
|
||||
|
||||
await monitor.start()
|
||||
assert monitor.is_running
|
||||
assert monitor.uptime is not None
|
||||
|
||||
await monitor.stop()
|
||||
assert not monitor.is_running
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_context_manager(self):
|
||||
"""Test monitor as async context manager."""
|
||||
async with ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False)
|
||||
) as monitor:
|
||||
assert monitor.is_running
|
||||
|
||||
# Register a config
|
||||
config_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(),
|
||||
test_url="https://example.com"
|
||||
)
|
||||
assert monitor.registered_count == 1
|
||||
|
||||
# After context exit, should be stopped
|
||||
assert not monitor.is_running
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_double_start(self):
|
||||
"""Test that double start is handled gracefully."""
|
||||
monitor = ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False)
|
||||
)
|
||||
|
||||
await monitor.start()
|
||||
await monitor.start() # Should log warning but not fail
|
||||
|
||||
assert monitor.is_running
|
||||
await monitor.stop()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_stop_without_start(self):
|
||||
"""Test that stop without start is handled gracefully."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
await monitor.stop() # Should log warning but not fail
|
||||
|
||||
|
||||
class TestConfigHealthMonitorHealthChecks:
|
||||
"""Health checking tests."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_manual_health_check_success(self):
|
||||
"""Test manual health check on a working URL."""
|
||||
async with ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False)
|
||||
) as monitor:
|
||||
config_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(page_timeout=30000),
|
||||
test_url="https://example.com",
|
||||
config_id="example_test"
|
||||
)
|
||||
|
||||
# Perform health check
|
||||
is_healthy = await monitor.check_health(config_id)
|
||||
|
||||
assert is_healthy is True
|
||||
|
||||
# Check state
|
||||
status = monitor.get_health_status(config_id)
|
||||
assert status.status == "healthy"
|
||||
assert status.consecutive_failures == 0
|
||||
assert status.consecutive_successes == 1
|
||||
assert status.last_check_time is not None
|
||||
assert status.last_success_time is not None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_manual_health_check_failure(self):
|
||||
"""Test manual health check on a non-existent URL."""
|
||||
async with ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False)
|
||||
) as monitor:
|
||||
config_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(page_timeout=10000),
|
||||
test_url="https://this-domain-definitely-does-not-exist-12345.com",
|
||||
config_id="failing_test"
|
||||
)
|
||||
|
||||
# Perform health check
|
||||
is_healthy = await monitor.check_health(config_id)
|
||||
|
||||
assert is_healthy is False
|
||||
|
||||
# Check state
|
||||
status = monitor.get_health_status(config_id)
|
||||
assert status.consecutive_failures == 1
|
||||
assert status.last_error is not None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_nonexistent_config(self):
|
||||
"""Test health check on non-existent config raises error."""
|
||||
async with ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False)
|
||||
) as monitor:
|
||||
with pytest.raises(ValueError, match="not registered"):
|
||||
await monitor.check_health("nonexistent")
|
||||
|
||||
|
||||
class TestConfigHealthMonitorResolution:
|
||||
"""Resolution strategy tests."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_set_default_resolution_strategy(self):
|
||||
"""Test setting a default resolution strategy."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
async def dummy_strategy(state, monitor):
|
||||
return ResolutionResult(success=True, action="dummy")
|
||||
|
||||
monitor.set_resolution_strategy(dummy_strategy)
|
||||
assert monitor._default_resolution_strategy == dummy_strategy
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_set_config_specific_resolution_strategy(self):
|
||||
"""Test setting a config-specific resolution strategy."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
config_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(),
|
||||
test_url="https://example.com",
|
||||
config_id="with_strategy"
|
||||
)
|
||||
|
||||
async def custom_strategy(state, monitor):
|
||||
return ResolutionResult(success=True, action="custom")
|
||||
|
||||
monitor.set_resolution_strategy(custom_strategy, config_id)
|
||||
assert monitor._resolution_strategies[config_id] == custom_strategy
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_set_strategy_for_nonexistent_config(self):
|
||||
"""Test setting strategy for non-existent config raises error."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
async def dummy_strategy(state, monitor):
|
||||
return ResolutionResult(success=True, action="dummy")
|
||||
|
||||
with pytest.raises(ValueError, match="not registered"):
|
||||
monitor.set_resolution_strategy(dummy_strategy, "nonexistent")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_register_with_resolution_strategy(self):
|
||||
"""Test registering a config with a resolution strategy."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
async def custom_strategy(state, monitor):
|
||||
return ResolutionResult(success=True, action="custom")
|
||||
|
||||
config_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(),
|
||||
test_url="https://example.com",
|
||||
resolution_strategy=custom_strategy
|
||||
)
|
||||
|
||||
assert monitor._resolution_strategies[config_id] == custom_strategy
|
||||
|
||||
|
||||
class TestConfigHealthMonitorMetrics:
|
||||
"""Metrics and status query tests."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_health_status_single(self):
|
||||
"""Test getting status for a single config."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
config_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(),
|
||||
test_url="https://example.com",
|
||||
config_id="status_test"
|
||||
)
|
||||
|
||||
status = monitor.get_health_status(config_id)
|
||||
|
||||
assert isinstance(status, ConfigHealthState)
|
||||
assert status.config_id == config_id
|
||||
assert status.status == "healthy"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_health_status_all(self):
|
||||
"""Test getting status for all configs."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
# Register multiple configs
|
||||
for i in range(3):
|
||||
monitor.register_config(
|
||||
config=CrawlerRunConfig(),
|
||||
test_url="https://example.com",
|
||||
config_id=f"config_{i}"
|
||||
)
|
||||
|
||||
all_statuses = monitor.get_health_status()
|
||||
|
||||
assert isinstance(all_statuses, dict)
|
||||
assert len(all_statuses) == 3
|
||||
assert all(isinstance(s, ConfigHealthState) for s in all_statuses.values())
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_health_status_nonexistent(self):
|
||||
"""Test getting status for non-existent config raises error."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
with pytest.raises(ValueError, match="not registered"):
|
||||
monitor.get_health_status("nonexistent")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_metrics_empty(self):
|
||||
"""Test getting metrics with no configs."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
metrics = monitor.get_metrics()
|
||||
|
||||
assert metrics["total_checks"] == 0
|
||||
assert metrics["successful_checks"] == 0
|
||||
assert metrics["failed_checks"] == 0
|
||||
assert metrics["success_rate"] == 0.0
|
||||
assert metrics["configs"] == {}
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_metrics_with_checks(self):
|
||||
"""Test metrics after performing health checks."""
|
||||
async with ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False),
|
||||
enable_metrics=True
|
||||
) as monitor:
|
||||
config_id = monitor.register_config(
|
||||
config=CrawlerRunConfig(),
|
||||
test_url="https://example.com",
|
||||
config_id="metrics_test"
|
||||
)
|
||||
|
||||
# Perform a health check
|
||||
await monitor.check_health(config_id)
|
||||
|
||||
metrics = monitor.get_metrics()
|
||||
|
||||
assert metrics["total_checks"] >= 0
|
||||
assert "configs" in metrics
|
||||
assert config_id in metrics["configs"]
|
||||
|
||||
config_metrics = metrics["configs"][config_id]
|
||||
assert config_metrics["status"] == "healthy"
|
||||
assert config_metrics["total_checks"] >= 1
|
||||
assert "avg_response_time" in config_metrics
|
||||
|
||||
|
||||
class TestConfigHealthMonitorProperties:
|
||||
"""Property tests."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_is_running_property(self):
|
||||
"""Test is_running property."""
|
||||
monitor = ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False)
|
||||
)
|
||||
|
||||
assert monitor.is_running is False
|
||||
|
||||
await monitor.start()
|
||||
assert monitor.is_running is True
|
||||
|
||||
await monitor.stop()
|
||||
assert monitor.is_running is False
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_registered_count_property(self):
|
||||
"""Test registered_count property."""
|
||||
monitor = ConfigHealthMonitor()
|
||||
|
||||
assert monitor.registered_count == 0
|
||||
|
||||
for i in range(5):
|
||||
monitor.register_config(
|
||||
config=CrawlerRunConfig(),
|
||||
test_url="https://httpbin.org/html",
|
||||
config_id=f"count_test_{i}"
|
||||
)
|
||||
|
||||
assert monitor.registered_count == 5
|
||||
|
||||
monitor.unregister_config("count_test_0")
|
||||
assert monitor.registered_count == 4
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_uptime_property(self):
|
||||
"""Test uptime property."""
|
||||
monitor = ConfigHealthMonitor(
|
||||
browser_config=BrowserConfig(headless=True, verbose=False)
|
||||
)
|
||||
|
||||
assert monitor.uptime is None
|
||||
|
||||
await monitor.start()
|
||||
await asyncio.sleep(0.1)
|
||||
|
||||
uptime = monitor.uptime
|
||||
assert uptime is not None
|
||||
assert uptime >= 0.1
|
||||
|
||||
await monitor.stop()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
pytest.main([__file__, "-v", "-s"])
|
||||
|
||||
Reference in New Issue
Block a user