| """ |
| HuggingFace Spaces Debug Helper |
| ================================ |
| Adds real-time error logging and debug endpoints for easier debugging |
| without rebuilding Docker every time. |
| """ |
|
|
| import sys |
| import io |
| import traceback |
| import logging |
| from datetime import datetime |
| from pathlib import Path |
| from collections import deque |
| from threading import Lock |
|
|
| class DebugLogger: |
| """ |
| Captures all errors and prints them both to console and stores them |
| for viewing via web dashboard /debug endpoint. |
| """ |
| |
| def __init__(self, max_errors=100, log_file="/home/user/app/logs/debug.log"): |
| self.errors = deque(maxlen=max_errors) |
| self.lock = Lock() |
| self.log_file = Path(log_file) |
| self.log_file.parent.mkdir(parents=True, exist_ok=True) |
| |
| |
| self.file_handler = logging.FileHandler(self.log_file) |
| self.file_handler.setLevel(logging.ERROR) |
| formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') |
| self.file_handler.setFormatter(formatter) |
| |
| |
| logging.getLogger().addHandler(self.file_handler) |
| |
| def log_error(self, error_type, error_msg, tb_str=None): |
| """Log an error with timestamp and traceback""" |
| timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") |
| |
| error_entry = { |
| 'timestamp': timestamp, |
| 'type': error_type, |
| 'message': str(error_msg), |
| 'traceback': tb_str or '' |
| } |
| |
| with self.lock: |
| self.errors.append(error_entry) |
| |
| |
| print(f"\n{'='*80}") |
| print(f"🔴 ERROR CAPTURED: {timestamp}") |
| print(f"{'='*80}") |
| print(f"Type: {error_type}") |
| print(f"Message: {error_msg}") |
| if tb_str: |
| print(f"\nTraceback:") |
| print(tb_str) |
| print(f"{'='*80}\n") |
| |
| |
| with open(self.log_file, 'a') as f: |
| f.write(f"\n{'='*80}\n") |
| f.write(f"ERROR: {timestamp}\n") |
| f.write(f"Type: {error_type}\n") |
| f.write(f"Message: {error_msg}\n") |
| if tb_str: |
| f.write(f"Traceback:\n{tb_str}\n") |
| f.write(f"{'='*80}\n") |
| |
| def get_recent_errors(self, count=20): |
| """Get the most recent N errors""" |
| with self.lock: |
| return list(self.errors)[-count:] |
| |
| def get_all_errors(self): |
| """Get all stored errors""" |
| with self.lock: |
| return list(self.errors) |
| |
| def clear_errors(self): |
| """Clear all stored errors""" |
| with self.lock: |
| self.errors.clear() |
| print("✅ Debug error log cleared") |
| |
| def get_log_file_contents(self): |
| """Read the debug log file""" |
| try: |
| if self.log_file.exists(): |
| with open(self.log_file, 'r') as f: |
| return f.read() |
| return "No debug log file found" |
| except Exception as e: |
| return f"Error reading log file: {e}" |
|
|
| |
| debug_logger = DebugLogger() |
|
|
|
|
| def capture_exception(func): |
| """ |
| Decorator to capture and log exceptions from any function |
| """ |
| def wrapper(*args, **kwargs): |
| try: |
| return func(*args, **kwargs) |
| except Exception as e: |
| error_type = type(e).__name__ |
| error_msg = str(e) |
| tb_str = traceback.format_exc() |
| |
| debug_logger.log_error(error_type, error_msg, tb_str) |
| raise |
| |
| return wrapper |
|
|
|
|
| def add_debug_routes(app): |
| """ |
| Add debug routes to Flask app |
| |
| Usage: |
| from debug_helper import add_debug_routes |
| add_debug_routes(app) |
| """ |
| |
| @app.route('/debug') |
| def debug_page(): |
| """HTML page showing recent errors""" |
| errors = debug_logger.get_all_errors() |
| |
| html = """ |
| <!DOCTYPE html> |
| <html> |
| <head> |
| <title>K1RL QUASAR Debug Dashboard</title> |
| <style> |
| body { |
| background: #0a0e27; |
| color: #00ff9d; |
| font-family: 'Courier New', monospace; |
| padding: 20px; |
| margin: 0; |
| } |
| .header { |
| text-align: center; |
| padding: 20px; |
| border-bottom: 2px solid #00ff9d; |
| margin-bottom: 20px; |
| } |
| .error-card { |
| background: #1a1f3a; |
| border: 1px solid #00ff9d; |
| border-radius: 5px; |
| padding: 15px; |
| margin-bottom: 15px; |
| box-shadow: 0 0 10px rgba(0, 255, 157, 0.2); |
| } |
| .error-header { |
| display: flex; |
| justify-content: space-between; |
| margin-bottom: 10px; |
| padding-bottom: 10px; |
| border-bottom: 1px solid #00ff9d; |
| } |
| .error-type { |
| color: #ff3366; |
| font-weight: bold; |
| } |
| .error-timestamp { |
| color: #888; |
| font-size: 0.9em; |
| } |
| .error-message { |
| color: #ffaa00; |
| margin: 10px 0; |
| } |
| .error-traceback { |
| background: #000; |
| padding: 10px; |
| border-radius: 3px; |
| overflow-x: auto; |
| font-size: 0.85em; |
| color: #00ff9d; |
| white-space: pre; |
| } |
| .controls { |
| text-align: center; |
| margin: 20px 0; |
| } |
| button { |
| background: #00ff9d; |
| color: #0a0e27; |
| border: none; |
| padding: 10px 20px; |
| border-radius: 5px; |
| cursor: pointer; |
| font-weight: bold; |
| margin: 0 5px; |
| } |
| button:hover { |
| background: #00cc7d; |
| } |
| .no-errors { |
| text-align: center; |
| padding: 40px; |
| color: #00ff9d; |
| font-size: 1.2em; |
| } |
| .stats { |
| text-align: center; |
| margin: 20px 0; |
| padding: 10px; |
| background: #1a1f3a; |
| border-radius: 5px; |
| } |
| </style> |
| <script> |
| function refresh() { |
| location.reload(); |
| } |
| function clearErrors() { |
| fetch('/debug/clear', {method: 'POST'}) |
| .then(() => location.reload()); |
| } |
| // Auto-refresh every 10 seconds |
| setTimeout(refresh, 10000); |
| </script> |
| </head> |
| <body> |
| <div class="header"> |
| <h1>🔴 K1RL QUASAR Debug Dashboard</h1> |
| <p>Real-time error monitoring for HuggingFace Spaces</p> |
| </div> |
| |
| <div class="stats"> |
| <strong>Total Errors Captured:</strong> """ + str(len(errors)) + """<br> |
| <small>Auto-refreshes every 10 seconds</small> |
| </div> |
| |
| <div class="controls"> |
| <button onclick="refresh()">🔄 Refresh Now</button> |
| <button onclick="clearErrors()">🗑️ Clear All Errors</button> |
| <button onclick="window.location.href='/debug/logs'">📄 View Full Log File</button> |
| <button onclick="window.location.href='/'">🏠 Back to Dashboard</button> |
| </div> |
| """ |
| |
| if not errors: |
| html += """ |
| <div class="no-errors"> |
| ✅ No errors captured yet<br> |
| <small>Errors will appear here when they occur</small> |
| </div> |
| """ |
| else: |
| |
| for error in reversed(errors): |
| html += f""" |
| <div class="error-card"> |
| <div class="error-header"> |
| <span class="error-type">{error['type']}</span> |
| <span class="error-timestamp">{error['timestamp']}</span> |
| </div> |
| <div class="error-message">{error['message']}</div> |
| """ |
| if error['traceback']: |
| html += f""" |
| <div class="error-traceback">{error['traceback']}</div> |
| """ |
| html += """ |
| </div> |
| """ |
| |
| html += """ |
| </body> |
| </html> |
| """ |
| return html |
| |
| @app.route('/debug/clear', methods=['POST']) |
| def clear_errors(): |
| """Clear all stored errors""" |
| debug_logger.clear_errors() |
| return {'status': 'success', 'message': 'Errors cleared'} |
| |
| @app.route('/debug/logs') |
| def view_log_file(): |
| """View the raw debug log file""" |
| log_contents = debug_logger.get_log_file_contents() |
| return f""" |
| <!DOCTYPE html> |
| <html> |
| <head> |
| <title>Debug Log File</title> |
| <style> |
| body {{ |
| background: #0a0e27; |
| color: #00ff9d; |
| font-family: 'Courier New', monospace; |
| padding: 20px; |
| }} |
| pre {{ |
| background: #000; |
| padding: 20px; |
| border-radius: 5px; |
| overflow-x: auto; |
| }} |
| button {{ |
| background: #00ff9d; |
| color: #0a0e27; |
| border: none; |
| padding: 10px 20px; |
| border-radius: 5px; |
| cursor: pointer; |
| font-weight: bold; |
| margin: 10px 5px; |
| }} |
| </style> |
| </head> |
| <body> |
| <h1>📄 Debug Log File</h1> |
| <button onclick="window.location.href='/debug'">🔙 Back to Debug Dashboard</button> |
| <button onclick="location.reload()">🔄 Refresh</button> |
| <pre>{log_contents}</pre> |
| </body> |
| </html> |
| """ |
| |
| print("✅ Debug routes added: /debug, /debug/clear, /debug/logs") |
|
|
|
|
| def patch_quantum_meta_controller(): |
| """ |
| Monkey-patch the QuantumMetaController to use debug logging |
| Call this before creating the controller instance |
| """ |
| print("🔧 Patching QuantumMetaController for better error logging...") |
| |
| |
| import types |
| |
| def patched_run_with_cleanup(original_func): |
| def wrapper(*args, **kwargs): |
| try: |
| return original_func(*args, **kwargs) |
| except Exception as e: |
| error_type = type(e).__name__ |
| error_msg = str(e) |
| tb_str = traceback.format_exc() |
| |
| debug_logger.log_error(error_type, error_msg, tb_str) |
| |
| |
| if len(args) > 0 and isinstance(args[0], dict): |
| args[0]['error'] = e |
| |
| raise |
| return wrapper |
| |
| print("✅ QuantumMetaController patched for debug logging") |
|
|
|
|
| if __name__ == "__main__": |
| |
| print("Testing debug logger...") |
| |
| try: |
| raise ValueError("This is a test error") |
| except Exception as e: |
| debug_logger.log_error( |
| type(e).__name__, |
| str(e), |
| traceback.format_exc() |
| ) |
| |
| print(f"\nCaptured {len(debug_logger.get_all_errors())} errors") |
| print("\nRecent errors:") |
| for error in debug_logger.get_recent_errors(): |
| print(f" - {error['timestamp']}: {error['type']} - {error['message']}") |
