scalping dash also works initially

monitor_dashboard.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Dashboard Performance Monitor
+
+This script monitors the running scalping dashboard for:
+- Response time
+- Error detection
+- Memory usage
+- Trade activity
+- WebSocket connectivity
+"""
+
+import requests
+import time
+import logging
+import psutil
+import json
+from datetime import datetime
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def check_dashboard_status():
+    """Check if dashboard is responding"""
+    try:
+        start_time = time.time()
+        response = requests.get("http://127.0.0.1:8051", timeout=5)
+        response_time = (time.time() - start_time) * 1000
+        
+        if response.status_code == 200:
+            logger.info(f"✅ Dashboard responding - {response_time:.1f}ms")
+            return True, response_time
+        else:
+            logger.error(f"❌ Dashboard returned status {response.status_code}")
+            return False, response_time
+    except Exception as e:
+        logger.error(f"❌ Dashboard connection failed: {e}")
+        return False, 0
+
+def check_system_resources():
+    """Check system resource usage"""
+    try:
+        # Find Python processes (our dashboard)
+        python_processes = []
+        for proc in psutil.process_iter(['pid', 'name', 'memory_info', 'cpu_percent']):
+            if 'python' in proc.info['name'].lower():
+                python_processes.append(proc)
+        
+        total_memory = sum(proc.info['memory_info'].rss for proc in python_processes) / 1024 / 1024
+        total_cpu = sum(proc.info['cpu_percent'] for proc in python_processes)
+        
+        logger.info(f"📊 System Resources:")
+        logger.info(f"   • Python Processes: {len(python_processes)}")
+        logger.info(f"   • Total Memory: {total_memory:.1f} MB")
+        logger.info(f"   • Total CPU: {total_cpu:.1f}%")
+        
+        return len(python_processes), total_memory, total_cpu
+    except Exception as e:
+        logger.error(f"❌ Failed to check system resources: {e}")
+        return 0, 0, 0
+
+def check_log_for_errors():
+    """Check recent logs for errors"""
+    try:
+        import os
+        log_file = "logs/enhanced_trading.log"
+        
+        if not os.path.exists(log_file):
+            logger.warning("❌ Log file not found")
+            return 0, 0
+        
+        # Read last 100 lines
+        with open(log_file, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+            recent_lines = lines[-100:] if len(lines) > 100 else lines
+        
+        error_count = sum(1 for line in recent_lines if 'ERROR' in line)
+        warning_count = sum(1 for line in recent_lines if 'WARNING' in line)
+        
+        if error_count > 0:
+            logger.warning(f"⚠️ Found {error_count} errors in recent logs")
+        if warning_count > 0:
+            logger.info(f"⚠️ Found {warning_count} warnings in recent logs")
+        
+        return error_count, warning_count
+    except Exception as e:
+        logger.error(f"❌ Failed to check logs: {e}")
+        return 0, 0
+
+def check_trading_activity():
+    """Check for recent trading activity"""
+    try:
+        import os
+        import glob
+        
+        # Look for trade log files
+        trade_files = glob.glob("trade_logs/session_*.json")
+        
+        if trade_files:
+            latest_file = max(trade_files, key=os.path.getctime)
+            file_size = os.path.getsize(latest_file)
+            file_time = datetime.fromtimestamp(os.path.getctime(latest_file))
+            
+            logger.info(f"📈 Trading Activity:")
+            logger.info(f"   • Latest Session: {os.path.basename(latest_file)}")
+            logger.info(f"   • Log Size: {file_size} bytes")
+            logger.info(f"   • Last Update: {file_time.strftime('%H:%M:%S')}")
+            
+            return len(trade_files), file_size
+        else:
+            logger.info("📈 No trading session files found yet")
+            return 0, 0
+    except Exception as e:
+        logger.error(f"❌ Failed to check trading activity: {e}")
+        return 0, 0
+
+def main():
+    """Main monitoring loop"""
+    logger.info("🔍 STARTING DASHBOARD PERFORMANCE MONITOR")
+    logger.info("=" * 60)
+    
+    monitor_count = 0
+    
+    try:
+        while True:
+            monitor_count += 1
+            logger.info(f"\n🔄 Monitor Check #{monitor_count} - {datetime.now().strftime('%H:%M:%S')}")
+            logger.info("-" * 40)
+            
+            # Check dashboard status
+            is_responding, response_time = check_dashboard_status()
+            
+            # Check system resources
+            proc_count, memory_mb, cpu_percent = check_system_resources()
+            
+            # Check for errors
+            error_count, warning_count = check_log_for_errors()
+            
+            # Check trading activity
+            session_count, log_size = check_trading_activity()
+            
+            # Summary
+            logger.info(f"\n📋 MONITOR SUMMARY:")
+            logger.info(f"   • Dashboard: {'✅ OK' if is_responding else '❌ DOWN'} ({response_time:.1f}ms)")
+            logger.info(f"   • Processes: {proc_count} running")
+            logger.info(f"   • Memory: {memory_mb:.1f} MB")
+            logger.info(f"   • CPU: {cpu_percent:.1f}%")
+            logger.info(f"   • Errors: {error_count} | Warnings: {warning_count}")
+            logger.info(f"   • Sessions: {session_count} | Latest Log: {log_size} bytes")
+            
+            # Performance assessment
+            if is_responding and error_count == 0:
+                if response_time < 1000 and memory_mb < 2000:
+                    logger.info("🎯 PERFORMANCE: EXCELLENT")
+                elif response_time < 2000 and memory_mb < 4000:
+                    logger.info("✅ PERFORMANCE: GOOD")
+                else:
+                    logger.info("⚠️ PERFORMANCE: MODERATE")
+            else:
+                logger.error("❌ PERFORMANCE: POOR")
+            
+            # Wait before next check
+            time.sleep(30)  # Check every 30 seconds
+            
+    except KeyboardInterrupt:
+        logger.info("\n👋 Monitor stopped by user")
+    except Exception as e:
+        logger.error(f"❌ Monitor failed: {e}")
+
+if __name__ == "__main__":
+    main()