Recovered state: integrated TrendSurferAgent, restored frontend/backend files, and cleaned up recovery scripts

backend/services/scheduler/core/interval_manager.py

@@ -7,9 +7,8 @@ from typing import TYPE_CHECKING
 from datetime import datetime
 from sqlalchemy.orm import Session
 
-from services.database import get_db_session
+from services.database import get_all_user_ids, get_session_for_user
 from utils.logger_utils import get_service_logger
-from models.scheduler_models import SchedulerEventLog
 
 if TYPE_CHECKING:
     from .scheduler import TaskScheduler
@@ -23,7 +22,7 @@ async def determine_optimal_interval(
     max_interval: int
 ) -> int:
     """
-    Determine optimal check interval based on active strategies.
+    Determine optimal check interval based on active strategies across all users.
     
     Args:
         scheduler: TaskScheduler instance
@@ -33,107 +32,100 @@ async def determine_optimal_interval(
     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()
+    total_active_count = 0
+    user_ids = get_all_user_ids()
     
-    # Default to shorter interval on error (safer)
-    return min_interval
+    for user_id in user_ids:
+        db = None
+        try:
+            db = get_session_for_user(user_id)
+            if db:
+                try:
+                    from services.active_strategy_service import ActiveStrategyService
+                    active_strategy_service = ActiveStrategyService(db_session=db)
+                    user_active_count = active_strategy_service.count_active_strategies_with_tasks()
+                    total_active_count += user_active_count
+                    
+                    # Optimization: If we found at least one active strategy, we can stop and return min_interval
+                    # (unless we want accurate stats)
+                    # For stats accuracy, we should continue.
+                except Exception as e:
+                    logger.warning(f"Error counting active strategies for user {user_id}: {e}")
+        except Exception as e:
+            logger.warning(f"Error checking user {user_id} for strategies: {e}")
+        finally:
+            if db:
+                db.close()
+                
+    scheduler.stats['active_strategies_count'] = total_active_count
+    
+    if total_active_count > 0:
+        logger.info(f"Found {total_active_count} active strategies across users - using {min_interval}min interval")
+        return min_interval
+    else:
+        logger.info(f"No active strategies found - using {max_interval}min interval")
+        return max_interval
 
 
 async def adjust_check_interval_if_needed(
     scheduler: 'TaskScheduler',
-    db: Session
+    db: Session = None  # Deprecated parameter, ignored
 ):
     """
-    Intelligently adjust check interval based on active strategies.
+    Intelligently adjust check interval based on active strategies across all users.
     
     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
+        db: Deprecated/Ignored
     """
-    try:
-        from services.active_strategy_service import ActiveStrategyService
+    total_active_count = 0
+    user_ids = get_all_user_ids()
+    
+    for user_id in user_ids:
+        user_db = None
+        try:
+            user_db = get_session_for_user(user_id)
+            if user_db:
+                try:
+                    from services.active_strategy_service import ActiveStrategyService
+                    active_strategy_service = ActiveStrategyService(db_session=user_db)
+                    user_active_count = active_strategy_service.count_active_strategies_with_tasks()
+                    total_active_count += user_active_count
+                except Exception as e:
+                    logger.warning(f"Error counting active strategies for user {user_id}: {e}")
+        except Exception as e:
+            logger.warning(f"Error checking user {user_id} for strategies: {e}")
+        finally:
+            if user_db:
+                user_db.close()
+    
+    scheduler.stats['active_strategies_count'] = total_active_count
+    
+    # Determine optimal interval
+    if total_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: {total_active_count}\n"
+            f"   └─ Reason: {'Active strategies detected' if total_active_count > 0 else 'No active strategies'}"
+        )
+        logger.warning(interval_message)
         
-        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}")
+        # Reschedule the job with new interval
+        scheduler.scheduler.modify_job(
+            job_id='check_due_tasks',  # Fixed job_id from check_cycle to check_due_tasks to match scheduler.py
+            trigger=scheduler._get_trigger_for_interval(optimal_interval)
+        )
+        scheduler.current_check_interval_minutes = optimal_interval
+        scheduler.stats['last_interval_adjustment'] = datetime.utcnow().isoformat()