Add robust error handling and logging for HF Spaces

Dockerfile

@@ -12,12 +12,15 @@ RUN apt-get update && apt-get install -y \
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
+# Create necessary directories with proper permissions
+RUN mkdir -p /code/static/uploads \
+    && mkdir -p /code/logs \
+    && chmod -R 777 /code/static/uploads \
+    && chmod -R 777 /code/logs
+
 # Copy the rest of the application
 COPY . .
 
-# Create necessary directories
-RUN mkdir -p static/uploads
-
 # Set environment variables
 ENV PYTHONUNBUFFERED=1
 ENV FLASK_APP=app.py

app.py

@@ -36,19 +36,35 @@ from bodybuilding_pose_analyzer.src.movenet_analyzer import MoveNetAnalyzer
 from bodybuilding_pose_analyzer.src.pose_analyzer import PoseAnalyzer
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
+# Add file handler for persistent logging
+log_dir = 'logs'
+os.makedirs(log_dir, exist_ok=True)
+file_handler = logging.FileHandler(os.path.join(log_dir, 'app.log'))
+file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+logger.addHandler(file_handler)
+
 def log_memory_usage():
     """Log current memory usage."""
-    process = psutil.Process()
-    memory_info = process.memory_info()
-    logger.info(f"Memory usage: {memory_info.rss / 1024 / 1024:.2f} MB")
+    try:
+        process = psutil.Process()
+        memory_info = process.memory_info()
+        logger.info(f"Memory usage: {memory_info.rss / 1024 / 1024:.2f} MB")
+    except Exception as e:
+        logger.error(f"Error logging memory usage: {e}")
 
 def cleanup_memory():
     """Force garbage collection and log memory usage."""
-    gc.collect()
-    log_memory_usage()
+    try:
+        gc.collect()
+        log_memory_usage()
+    except Exception as e:
+        logger.error(f"Error in cleanup_memory: {e}")
 
 def wrap_text(text: str, font_face: int, font_scale: float, thickness: int, max_width: int) -> list[str]:
     """Wrap text to fit within max_width."""
@@ -94,8 +110,17 @@ app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100MB max file size
 os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
 
 # Load CNN model for bodybuilding pose classification
-cnn_model_path = 'external/BodybuildingPoseClassifier/bodybuilding_pose_classifier.h5'
-cnn_model = load_model(cnn_model_path)
+try:
+    logger.info("Loading CNN model...")
+    cnn_model_path = 'external/BodybuildingPoseClassifier/bodybuilding_pose_classifier.h5'
+    if not os.path.exists(cnn_model_path):
+        raise FileNotFoundError(f"CNN model not found at {cnn_model_path}")
+    cnn_model = load_model(cnn_model_path)
+    logger.info("CNN model loaded successfully")
+except Exception as e:
+    logger.error(f"Error loading CNN model: {e}")
+    raise
+
 cnn_class_labels = ['side_chest', 'front_double_biceps', 'back_double_biceps', 'front_lat_spread', 'back_lat_spread']
 
 def predict_pose_cnn(img_path):
@@ -387,7 +412,7 @@ def index():
 @app.route('/upload', methods=['POST'])
 def upload_file():
     try:
-        cleanup_memory()  # Clean up before processing
+        cleanup_memory()
         if 'video' not in request.files:
             logger.error("[UPLOAD] No video file in request")
             return jsonify({'error': 'No video file provided'}), 400
@@ -413,6 +438,9 @@ def upload_file():
             unique_filename = f"{base}_{int(time.time())}{ext}"
             filepath = os.path.join(app.config['UPLOAD_FOLDER'], unique_filename)
             
+            # Ensure upload directory exists
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+            
             logger.info(f"[UPLOAD] Saving file to: {filepath}")
             file.save(filepath)
             
@@ -435,8 +463,9 @@ def upload_file():
                     
                 logger.info(f"[UPLOAD] Processing complete. Output URL: {output_path_url}")
                 
-                if not os.path.exists(os.path.join(app.config['UPLOAD_FOLDER'], os.path.basename(output_path_url))):
-                    logger.error(f"[UPLOAD] Output file not found: {output_path_url}")
+                output_path = os.path.join(app.config['UPLOAD_FOLDER'], os.path.basename(output_path_url))
+                if not os.path.exists(output_path):
+                    logger.error(f"[UPLOAD] Output file not found: {output_path}")
                     return jsonify({'error': 'Output video file not found'}), 500
                     
                 return jsonify({
@@ -446,7 +475,7 @@ def upload_file():
                 
             except Exception as e:
                 logger.error(f"[UPLOAD] Error processing video: {str(e)}")
-                traceback.print_exc()
+                logger.error(traceback.format_exc())
                 return jsonify({'error': f'Error processing video: {str(e)}'}), 500
                 
             finally:
@@ -459,22 +488,25 @@ def upload_file():
                     
     except Exception as e:
         logger.error(f"[UPLOAD] Unexpected error: {str(e)}")
-        traceback.print_exc()
+        logger.error(traceback.format_exc())
         return jsonify({'error': 'Internal server error'}), 500
     finally:
-        cleanup_memory()  # Clean up after processing
+        cleanup_memory()
 
-# Add error handlers
+# Add more specific error handlers
 @app.errorhandler(413)
 def request_entity_too_large(error):
+    logger.error(f"File too large: {error}")
     return jsonify({'error': 'File too large. Maximum size is 100MB'}), 413
 
 @app.errorhandler(500)
 def internal_server_error(error):
+    logger.error(f"Internal server error: {error}")
     return jsonify({'error': 'Internal server error. Please try again later.'}), 500
 
 @app.errorhandler(404)
 def not_found_error(error):
+    logger.error(f"Resource not found: {error}")
     return jsonify({'error': 'Resource not found'}), 404
 
 if __name__ == '__main__':