main.py

from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel, EmailStr, Field
from typing import Optional, List
import logging
import time
from datetime import datetime

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Initialize FastAPI
app = FastAPI(
    title="FastAPI AWS Template",
    description="A template for deploying FastAPI applications on AWS Elastic Beanstalk",
    version="1.0.0"
)

# Pydantic Models
class UserBase(BaseModel):
    email: EmailStr
    username: str = Field(..., min_length=3, max_length=50)
    full_name: Optional[str] = None

class UserCreate(UserBase):
    password: str = Field(..., min_length=8)

class User(UserBase):
    id: int
    created_at: datetime
    
    class Config:
        from_attributes = True

# In-memory storage
users_db = []

# Middleware for request timing
@app.middleware("http")
async def add_process_time_header(request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    logger.info(f"Request processed in {process_time:.4f} seconds")
    return response

# Root endpoint
@app.get("/", 
         status_code=status.HTTP_200_OK,
         tags=["Health Check"])
async def root():
    logger.info("Health check endpoint called")
    return {
        "status": "healthy",
        "timestamp": datetime.now().isoformat(),
        "service": "FastAPI AWS Template"
    }

# User endpoints
@app.post("/users/", 
          response_model=User,
          status_code=status.HTTP_201_CREATED,
          tags=["Users"])
async def create_user(user: UserCreate):
    logger.info(f"Creating new user with username: {user.username}")
    
    # Check if user already exists
    if any(u.username == user.username for u in users_db):
        logger.warning(f"Username {user.username} already exists")
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Username already registered"
        )
    
    # Create new user
    new_user = User(
        id=len(users_db) + 1,
        email=user.email,
        username=user.username,
        full_name=user.full_name,
        created_at=datetime.now()
    )
    users_db.append(new_user)
    
    logger.info(f"User {new_user.username} created successfully")
    return new_user

@app.get("/users/", 
         response_model=List[User],
         status_code=status.HTTP_200_OK,
         tags=["Users"])
async def get_users():
    logger.info("Retrieving all users")
    return users_db

@app.get("/users/{user_id}", 
         response_model=User,
         status_code=status.HTTP_200_OK,
         tags=["Users"])
async def get_user(user_id: int):
    logger.info(f"Retrieving user with ID: {user_id}")
    
    user = next((u for u in users_db if u.id == user_id), None)
    if user is None:
        logger.warning(f"User with ID {user_id} not found")
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="User not found"
        )
    
    return user

# Error handlers
@app.exception_handler(HTTPException)
async def http_exception_handler(request, exc):
    logger.error(f"HTTP error occurred: {exc.detail}")
    return {
        "error": exc.detail,
        "status_code": exc.status_code,
        "timestamp": datetime.now().isoformat()
    }

# Startup event
@app.on_event("startup")
async def startup_event():
    logger.info("Application starting up...")
    # Add any initialization code here

# Shutdown event
@app.on_event("shutdown")
async def shutdown_event():
    logger.info("Application shutting down...")
    # Add any cleanup code here