Update app.py

app.py

@@ -1,161 +1,76 @@
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from contextlib import asynccontextmanager
-from agentpress.thread_manager import ThreadManager
-from services.supabase import DBConnection
-from datetime import datetime, timezone
-from dotenv import load_dotenv
-from utils.config import config, EnvMode
-import asyncio
-from utils.logger import logger
-import uuid
-import time
-from collections import OrderedDict
+FROM python:3.11-slim
 
-# Import the agent API module
-from agent import api as agent_api
-from sandbox import api as sandbox_api
-from services import billing as billing_api
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    ENV_MODE="production" \
+    PYTHONPATH=/app \
+    REDIS_URL="redis://localhost:6379/0"
 
-# Load environment variables (these will be available through config)
-load_dotenv()
+WORKDIR /app
 
-# Initialize managers
-db = DBConnection()
-thread_manager = None
-instance_id = "single"
+# Install system dependencies including Redis
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    redis-server \
+    && rm -rf /var/lib/apt/lists/*
 
-# Rate limiter state
-ip_tracker = OrderedDict()
-MAX_CONCURRENT_IPS = 25
+# Configure Redis
+RUN sed -i 's/bind 127.0.0.1 ::1/bind 0.0.0.0/' /etc/redis/redis.conf && \
+    sed -i 's/protected-mode yes/protected-mode no/' /etc/redis/redis.conf && \
+    sed -i 's/daemonize yes/daemonize no/' /etc/redis/redis.conf
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Startup
-    global thread_manager
-    logger.info(f"Starting up FastAPI application with instance ID: {instance_id} in {config.ENV_MODE.value} mode")
-    
-    try:
-        # Initialize database
-        await db.initialize()
-        thread_manager = ThreadManager()
-        
-        # Initialize the agent API with shared resources
-        agent_api.initialize(
-            thread_manager,
-            db,
-            instance_id
-        )
-        
-        # Initialize the sandbox API with shared resources
-        sandbox_api.initialize(db)
-        
-        # Initialize Redis connection
-        from services import redis
-        try:
-            await redis.initialize_async()
-            logger.info("Redis connection initialized successfully")
-        except Exception as e:
-            logger.error(f"Failed to initialize Redis connection: {e}")
-            # Continue without Redis - the application will handle Redis failures gracefully
-        
-        # Start background tasks
-        asyncio.create_task(agent_api.restore_running_agent_runs())
-        
-        yield
-        
-        # Clean up agent resources
-        logger.info("Cleaning up agent resources")
-        await agent_api.cleanup()
-        
-        # Clean up Redis connection
-        try:
-            logger.info("Closing Redis connection")
-            await redis.close()
-            logger.info("Redis connection closed successfully")
-        except Exception as e:
-            logger.error(f"Error closing Redis connection: {e}")
-        
-        # Clean up database connection
-        logger.info("Disconnecting from database")
-        await db.disconnect()
-    except Exception as e:
-        logger.error(f"Error during application startup: {e}")
-        raise
+# Create non-root user and set up directories
+RUN useradd -m -u 1000 appuser && \
+    mkdir -p /app/logs && \
+    chown -R appuser:appuser /app && \
+    chown -R appuser:appuser /var/lib/redis && \
+    chown -R appuser:appuser /var/log/redis && \
+    chown -R appuser:appuser /etc/redis
 
-app = FastAPI(lifespan=lifespan)
+# Install Python dependencies
+COPY --chown=appuser:appuser requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt gunicorn
 
-@app.middleware("http")
-async def log_requests_middleware(request: Request, call_next):
-    start_time = time.time()
-    client_ip = request.client.host
-    method = request.method
-    url = str(request.url)
-    path = request.url.path
-    query_params = str(request.query_params)
-    
-    # Log the incoming request
-    logger.info(f"Request started: {method} {path} from {client_ip} | Query: {query_params}")
-    
-    try:
-        response = await call_next(request)
-        process_time = time.time() - start_time
-        logger.debug(f"Request completed: {method} {path} | Status: {response.status_code} | Time: {process_time:.2f}s")
-        return response
-    except Exception as e:
-        process_time = time.time() - start_time
-        logger.error(f"Request failed: {method} {path} | Error: {str(e)} | Time: {process_time:.2f}s")
-        raise
+# Switch to non-root user
+USER appuser
 
-# Define allowed origins based on environment
-allowed_origins = ["https://www.suna.so", "https://suna.so", "https://staging.suna.so", "http://localhost:3000"]
+# Copy application code
+COPY --chown=appuser:appuser . .
 
-# Add staging-specific origins
-if config.ENV_MODE == EnvMode.STAGING:
-    allowed_origins.append("http://localhost:3000")
-    
-# Add local-specific origins
-if config.ENV_MODE == EnvMode.LOCAL:
-    allowed_origins.append("http://localhost:3000")
+# Expose the port the app runs on
+EXPOSE 7860 6379
 
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=allowed_origins,
-    allow_credentials=True,
-    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-    allow_headers=["Content-Type", "Authorization"],
-)
+# Calculate optimal worker count based on 16 vCPUs
+# Using (2*CPU)+1 formula for CPU-bound applications
+ENV WORKERS=33
+ENV THREADS=2
+ENV WORKER_CONNECTIONS=2000
 
-# Include the agent router with a prefix
-app.include_router(agent_api.router, prefix="/api")
+# Create a startup script to run both Redis and Gunicorn
+RUN echo '#!/bin/sh\n\
+redis-server /etc/redis/redis.conf &\n\
+gunicorn api:app \
+     --workers $WORKERS \
+     --worker-class uvicorn.workers.UvicornWorker \
+     --bind 0.0.0.0:7860 \
+     --timeout 600 \
+     --graceful-timeout 300 \
+     --keep-alive 250 \
+     --max-requests 2000 \
+     --max-requests-jitter 400 \
+     --forwarded-allow-ips '*' \
+     --worker-connections $WORKER_CONNECTIONS \
+     --worker-tmp-dir /dev/shm \
+     --preload \
+     --log-level info \
+     --access-logfile - \
+     --error-logfile - \
+     --capture-output \
+     --enable-stdio-inheritance \
+     --threads $THREADS\n\
+wait' > /app/start.sh && chmod +x /app/start.sh
 
-# Include the sandbox router with a prefix
-app.include_router(sandbox_api.router, prefix="/api")
-
-# Include the billing router with a prefix
-app.include_router(billing_api.router, prefix="/api")
-
-@app.get("/api/health")
-async def health_check():
-    """Health check endpoint to verify API is working."""
-    logger.info("Health check endpoint called")
-    return {
-        "status": "ok", 
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "instance_id": instance_id
-    }
-
-if __name__ == "__main__":
-    import uvicorn
-    
-    workers = 2
-    
-    logger.info(f"Starting server on 0.0.0.0:8000 with {workers} workers")
-    uvicorn.run(
-        "api:app", 
-        host="0.0.0.0", 
-        port=8000,
-        workers=workers,
-        reload=True
-    )
+# Run the startup script
+CMD ["/app/start.sh"]