test

Dockerfile

@@ -2,9 +2,11 @@ FROM python:3.9-slim
 
 # Set environment variables
 ENV FLASK_APP=app.py
-ENV FLASK_ENV=production
+ENV FLASK_ENV=development
 ENV PATH="/home/appuser/.local/bin:$PATH"
 ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV FLASK_DEBUG=1
 
 # Install system dependencies for OpenCV and other requirements
 RUN apt-get update && apt-get install -y \
@@ -43,8 +45,14 @@ RUN echo '#!/bin/sh\npython -c "import flask, flask_sqlalchemy, redis, celery; p
 # Copy the application code
 COPY --chown=appuser:appuser . .
 
+# Create a debug script
+RUN echo '#!/bin/bash\n\
+echo "Starting app in debug mode..."\n\
+python -m flask run --host=0.0.0.0 --port=5000 --debug\n\
+' > /app/debug.sh && chmod +x /app/debug.sh
+
 # Make scripts executable
-RUN chmod +x /app/prestart.sh /app/healthcheck.sh /app/start.sh
+RUN chmod +x /app/prestart.sh /app/healthcheck.sh /app/start.sh /app/debug.sh
 
 # Switch to non-root user
 USER appuser
@@ -52,5 +60,5 @@ USER appuser
 # Expose the port
 EXPOSE 5000
 
-# Run the application directly with gunicorn
-CMD ["gunicorn", "--config=./gunicorn.conf.py", "--workers=2", "app:create_app"]
+# Run the application in debug mode
+CMD ["python", "-m", "flask", "run", "--host=0.0.0.0", "--port=5000", "--debug"]

app/__init__.py

@@ -4,8 +4,18 @@ from flask_login import LoginManager
 from celery import Celery
 import redis
 import os
+import logging
+import sys
 from pathlib import Path
 
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger(__name__)
+
 # Initialize extensions
 db = SQLAlchemy()
 login = LoginManager()
@@ -14,42 +24,94 @@ celery = Celery(__name__)
 cache = None  # Initialize later when app context is available
 
 def create_app(config_class=None):
+    logger.info("Starting application initialization...")
+    
     # Create the Flask app
     app = Flask(__name__)
+    logger.info("Flask app created")
     
     # Load configuration
     if config_class is None:
+        logger.info("Loading default configuration...")
         app.config.from_object('config.Config')
     else:
+        logger.info(f"Loading configuration from {config_class}...")
         app.config.from_object(config_class)
     
     # Ensure instance path exists
+    logger.info(f"Ensuring instance path exists: {app.config['INSTANCE_PATH']}")
     Path(app.config['INSTANCE_PATH']).mkdir(parents=True, exist_ok=True)
     app.instance_path = app.config['INSTANCE_PATH']
     
     # Initialize extensions
+    logger.info("Initializing SQLAlchemy...")
     db.init_app(app)
+    
+    logger.info("Initializing LoginManager...")
     login.init_app(app)
     
     # Configure Celery
+    logger.info("Configuring Celery...")
     celery.conf.update(app.config)
     
     # Initialize Redis cache
-    global cache
-    cache = redis.Redis.from_url(app.config['CELERY_BROKER_URL'])
-    
-    # Register Blueprints
-    with app.app_context():
-        from .routes.auth import auth_bp
-        from .routes.dashboard import dashboard_bp
-        from .routes.api import api_bp
-        from .routes.compliance import compliance_bp
-        from .routes.google_ads import google_ads_bp
-        
-        app.register_blueprint(auth_bp)
-        app.register_blueprint(dashboard_bp)
-        app.register_blueprint(api_bp)
-        app.register_blueprint(compliance_bp)
-        app.register_blueprint(google_ads_bp)
+    try:
+        logger.info(f"Initializing Redis cache with URL: {app.config['CELERY_BROKER_URL']}")
+        global cache
+        cache = redis.Redis.from_url(app.config['CELERY_BROKER_URL'])
+        logger.info("Redis cache initialized successfully")
+    except Exception as e:
+        logger.error(f"Error initializing Redis cache: {e}")
+        # Continue without Redis for now
+        pass
+    
+    # Register test blueprint first (this should always work)
+    logger.info("Registering test blueprint...")
+    from .routes.test import test_bp
+    app.register_blueprint(test_bp)
+    
+    # Register other blueprints
+    logger.info("Registering other blueprints...")
+    try:
+        with app.app_context():
+            logger.info("Importing auth blueprint...")
+            from .routes.auth import auth_bp
+            
+            logger.info("Importing dashboard blueprint...")
+            from .routes.dashboard import dashboard_bp
+            
+            logger.info("Importing API blueprint...")
+            from .routes.api import api_bp
+            
+            logger.info("Importing compliance blueprint...")
+            from .routes.compliance import compliance_bp
+            
+            logger.info("Importing Google Ads blueprint...")
+            from .routes.google_ads import google_ads_bp
+            
+            logger.info("Registering auth blueprint...")
+            app.register_blueprint(auth_bp)
+            
+            logger.info("Registering dashboard blueprint...")
+            app.register_blueprint(dashboard_bp)
+            
+            logger.info("Registering API blueprint...")
+            app.register_blueprint(api_bp)
+            
+            logger.info("Registering compliance blueprint...")
+            app.register_blueprint(compliance_bp)
+            
+            logger.info("Registering Google Ads blueprint...")
+            app.register_blueprint(google_ads_bp)
+    except Exception as e:
+        logger.error(f"Error registering blueprints: {e}")
+        # Continue without all blueprints for debugging
+        pass
+    
+    # Add a simple route directly to the app
+    @app.route('/')
+    def index():
+        return 'Application is running! Try /test for the test endpoint.'
     
+    logger.info("Application initialization complete")
     return app

app/routes/test.py

@@ -0,0 +1,11 @@
+from flask import Blueprint, jsonify
+
+test_bp = Blueprint('test', __name__)
+
+@test_bp.route('/test', methods=['GET'])
+def test():
+    """Simple test endpoint to verify the application is working."""
+    return jsonify({
+        'status': 'success',
+        'message': 'The application is working!'
+    }) 

docker-compose.yml

@@ -8,8 +8,9 @@ services:
     ports:
       - "5000:5000"
     environment:
-      - FLASK_ENV=production
-      - DATABASE_URL=postgresql://postgres:example@postgres:5432/facebook_ads
+      - FLASK_ENV=development
+      - FLASK_DEBUG=1
+      - DATABASE_URL=sqlite:////tmp/app.db
       - CELERY_BROKER_URL=redis://redis:6379/0
       - CELERY_RESULT_BACKEND=redis://redis:6379/0
       - INSTANCE_PATH=/tmp/instance
@@ -20,8 +21,6 @@ services:
       - ./app/models:/app/models
     depends_on:
       - redis
-      - postgres
-      - selenium-hub
     restart: unless-stopped
     healthcheck:
       test: ["CMD", "/app/healthcheck.sh"]
@@ -30,43 +29,6 @@ services:
       retries: 3
       start_period: 40s
 
-  celery_worker:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    command: celery -A celery_worker.celery worker --loglevel=info
-    environment:
-      - FLASK_ENV=production
-      - DATABASE_URL=postgresql://postgres:example@postgres:5432/facebook_ads
-      - CELERY_BROKER_URL=redis://redis:6379/0
-      - CELERY_RESULT_BACKEND=redis://redis:6379/0
-      - INSTANCE_PATH=/tmp/instance
-      - SECRET_KEY=${SECRET_KEY:-default-dev-key-change-in-production}
-      - OPENAI_API_KEY=${OPENAI_API_KEY:-sk-mock-key-for-development}
-    volumes:
-      - ./app:/app/app
-    depends_on:
-      - web
-      - redis
-      - postgres
-    restart: unless-stopped
-
-  selenium-hub:
-    image: selenium/hub
-    ports:
-      - "4444:4444"
-    restart: unless-stopped
-
-  chrome-node:
-    image: selenium/node-chrome
-    shm_size: 2gb
-    depends_on:
-      - selenium-hub
-    environment:
-      - HUB_HOST=selenium-hub
-      - HUB_PORT=4444
-    restart: unless-stopped
-
   redis:
     image: redis:alpine
     ports:
@@ -80,22 +42,5 @@ services:
       timeout: 10s
       retries: 3
 
-  postgres:
-    image: postgres:14
-    environment:
-      - POSTGRES_PASSWORD=example
-      - POSTGRES_DB=facebook_ads
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-    ports:
-      - "5432:5432"
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-
 volumes:
-  postgres_data:
   redis_data:

run_docker.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+# run_docker.sh - Build and run the Docker container
+
+# Stop any running containers
+echo "Stopping any running containers..."
+docker stop facebook-ad-analytics-web 2>/dev/null || true
+docker rm facebook-ad-analytics-web 2>/dev/null || true
+
+# Build the Docker image
+echo "Building Docker image..."
+docker build -t facebook-ad-analytics .
+
+# Run the container
+echo "Running container..."
+docker run -d --name facebook-ad-analytics-web \
+  -p 5000:5000 \
+  -e FLASK_ENV=development \
+  -e FLASK_DEBUG=1 \
+  -e DATABASE_URL=sqlite:////tmp/app.db \
+  -e INSTANCE_PATH=/tmp/instance \
+  -e SECRET_KEY=dev-secret-key \
+  -e OPENAI_API_KEY=sk-mock-key-for-development \
+  facebook-ad-analytics
+
+# Follow the logs
+echo "Following logs..."
+docker logs -f facebook-ad-analytics-web