140 lines
5.3 KiB
Python
140 lines
5.3 KiB
Python
"""
|
|
Interval Manager
|
|
Handles intelligent scheduling interval adjustment based on active strategies.
|
|
"""
|
|
|
|
from typing import TYPE_CHECKING
|
|
from datetime import datetime
|
|
from sqlalchemy.orm import Session
|
|
|
|
from services.database import get_db_session
|
|
from utils.logger_utils import get_service_logger
|
|
from models.scheduler_models import SchedulerEventLog
|
|
|
|
if TYPE_CHECKING:
|
|
from .scheduler import TaskScheduler
|
|
|
|
logger = get_service_logger("interval_manager")
|
|
|
|
|
|
async def determine_optimal_interval(
|
|
scheduler: 'TaskScheduler',
|
|
min_interval: int,
|
|
max_interval: int
|
|
) -> int:
|
|
"""
|
|
Determine optimal check interval based on active strategies.
|
|
|
|
Args:
|
|
scheduler: TaskScheduler instance
|
|
min_interval: Minimum check interval in minutes
|
|
max_interval: Maximum check interval in minutes
|
|
|
|
Returns:
|
|
Optimal check interval in minutes
|
|
"""
|
|
db = None
|
|
try:
|
|
db = get_db_session()
|
|
if db:
|
|
from services.active_strategy_service import ActiveStrategyService
|
|
active_strategy_service = ActiveStrategyService(db_session=db)
|
|
active_count = active_strategy_service.count_active_strategies_with_tasks()
|
|
scheduler.stats['active_strategies_count'] = active_count
|
|
|
|
if active_count > 0:
|
|
logger.info(f"Found {active_count} active strategies with tasks - using {min_interval}min interval")
|
|
return min_interval
|
|
else:
|
|
logger.info(f"No active strategies with tasks - using {max_interval}min interval")
|
|
return max_interval
|
|
except Exception as e:
|
|
logger.warning(f"Error determining optimal interval: {e}, using default {min_interval}min")
|
|
finally:
|
|
if db:
|
|
db.close()
|
|
|
|
# Default to shorter interval on error (safer)
|
|
return min_interval
|
|
|
|
|
|
async def adjust_check_interval_if_needed(
|
|
scheduler: 'TaskScheduler',
|
|
db: Session
|
|
):
|
|
"""
|
|
Intelligently adjust check interval based on active strategies.
|
|
|
|
If there are active strategies with tasks, check more frequently.
|
|
If there are no active strategies, check less frequently.
|
|
|
|
Args:
|
|
scheduler: TaskScheduler instance
|
|
db: Database session
|
|
"""
|
|
try:
|
|
from services.active_strategy_service import ActiveStrategyService
|
|
|
|
active_strategy_service = ActiveStrategyService(db_session=db)
|
|
active_count = active_strategy_service.count_active_strategies_with_tasks()
|
|
scheduler.stats['active_strategies_count'] = active_count
|
|
|
|
# Determine optimal interval
|
|
if active_count > 0:
|
|
optimal_interval = scheduler.min_check_interval_minutes
|
|
else:
|
|
optimal_interval = scheduler.max_check_interval_minutes
|
|
|
|
# Only reschedule if interval needs to change
|
|
if optimal_interval != scheduler.current_check_interval_minutes:
|
|
interval_message = (
|
|
f"[Scheduler] ⚙️ Adjusting Check Interval\n"
|
|
f" ├─ Current: {scheduler.current_check_interval_minutes}min\n"
|
|
f" ├─ Optimal: {optimal_interval}min\n"
|
|
f" ├─ Active Strategies: {active_count}\n"
|
|
f" └─ Reason: {'Active strategies detected' if active_count > 0 else 'No active strategies'}"
|
|
)
|
|
logger.warning(interval_message)
|
|
|
|
# Reschedule the job with new interval
|
|
scheduler.scheduler.modify_job(
|
|
'check_due_tasks',
|
|
trigger=scheduler._get_trigger_for_interval(optimal_interval)
|
|
)
|
|
|
|
# Save previous interval before updating
|
|
previous_interval = scheduler.current_check_interval_minutes
|
|
|
|
# Update current interval
|
|
scheduler.current_check_interval_minutes = optimal_interval
|
|
scheduler.stats['last_interval_adjustment'] = datetime.utcnow().isoformat()
|
|
|
|
# Save interval adjustment event to database
|
|
try:
|
|
event_db = get_db_session()
|
|
if event_db:
|
|
event_log = SchedulerEventLog(
|
|
event_type='interval_adjustment',
|
|
event_date=datetime.utcnow(),
|
|
previous_interval_minutes=previous_interval,
|
|
new_interval_minutes=optimal_interval,
|
|
check_interval_minutes=optimal_interval,
|
|
active_strategies_count=active_count,
|
|
event_data={
|
|
'reason': 'intelligent_scheduling',
|
|
'min_interval': scheduler.min_check_interval_minutes,
|
|
'max_interval': scheduler.max_check_interval_minutes
|
|
}
|
|
)
|
|
event_db.add(event_log)
|
|
event_db.commit()
|
|
event_db.close()
|
|
except Exception as e:
|
|
logger.warning(f"Failed to save interval adjustment event log: {e}")
|
|
|
|
logger.warning(f"[Scheduler] ✅ Interval adjusted to {optimal_interval}min")
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Error adjusting check interval: {e}")
|
|
|