forked from mtusi2026/mtusi2026lab6
233 lines
6.1 KiB
Python
233 lines
6.1 KiB
Python
import asyncio
|
|
import logging
|
|
import time
|
|
import uuid
|
|
from contextlib import asynccontextmanager, suppress
|
|
from pathlib import Path
|
|
|
|
from fastapi import FastAPI, HTTPException, Request
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
from sqlalchemy import text
|
|
|
|
from app.api.auth import router as auth_router
|
|
from app.api.users import router as users_router
|
|
from app.api.chats import router as chats_router
|
|
from app.api.messages import router as messages_router
|
|
from app.api.attachments import router as attachments_router
|
|
from app.core.config import settings
|
|
from app.core.telemetry import setup_telemetry
|
|
from app.db.session import engine
|
|
from app.services.object_storage import client as s3_client
|
|
from app.services.attachment_cleanup import cleanup_expired_uploads
|
|
|
|
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
async def attachment_cleanup_loop():
|
|
while True:
|
|
try:
|
|
# Synchronous boto3/SQLAlchemy I/O must not block the event loop.
|
|
await asyncio.to_thread(cleanup_expired_uploads)
|
|
except Exception:
|
|
logger.exception("Attachment cleanup worker iteration failed")
|
|
|
|
await asyncio.sleep(settings.attachment_cleanup_interval_seconds)
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
logger.info("Application startup instance_id=%s", settings.instance_id)
|
|
|
|
cleanup_task = asyncio.create_task(attachment_cleanup_loop())
|
|
|
|
try:
|
|
yield
|
|
finally:
|
|
cleanup_task.cancel()
|
|
|
|
with suppress(asyncio.CancelledError):
|
|
await cleanup_task
|
|
|
|
engine.dispose()
|
|
logger.info("Application shutdown instance_id=%s", settings.instance_id)
|
|
|
|
|
|
app = FastAPI(
|
|
title=settings.app_name,
|
|
version="1.4.0",
|
|
lifespan=lifespan,
|
|
)
|
|
|
|
app.include_router(users_router)
|
|
app.include_router(auth_router)
|
|
app.include_router(chats_router)
|
|
app.include_router(messages_router)
|
|
app.include_router(attachments_router)
|
|
|
|
|
|
@app.middleware("http")
|
|
async def response_headers(request: Request, call_next):
|
|
request_id = str(uuid.uuid4())
|
|
request.state.request_id = request_id
|
|
|
|
started_at = time.perf_counter()
|
|
|
|
try:
|
|
response = await call_next(request)
|
|
|
|
except Exception:
|
|
logger.exception(
|
|
"Unhandled request error; request_id=%s",
|
|
request_id,
|
|
)
|
|
|
|
response = JSONResponse(
|
|
status_code=500,
|
|
content={
|
|
"error": {
|
|
"code": "internal_error",
|
|
"message": "Unexpected error",
|
|
"request_id": request_id,
|
|
}
|
|
},
|
|
)
|
|
|
|
duration_ms = (time.perf_counter() - started_at) * 1000
|
|
|
|
route = request.scope.get("route")
|
|
route_template = getattr(route, "path", "unmatched")
|
|
|
|
if route_template not in ("/health/live", "/health/ready"):
|
|
logger.info(
|
|
"HTTP request completed",
|
|
extra={
|
|
"event": "http_request_completed",
|
|
"http_method": request.method,
|
|
"http_route": route_template,
|
|
"http_status_code": response.status_code,
|
|
"http_duration_ms": round(duration_ms, 3),
|
|
},
|
|
)
|
|
|
|
response.headers["X-Request-Id"] = request_id
|
|
response.headers["X-Instance-Id"] = settings.instance_id
|
|
response.headers["X-Content-Type-Options"] = "nosniff"
|
|
|
|
return response
|
|
|
|
|
|
# Initialize OpenTelemetry AFTER registering the application middleware.
|
|
# This makes OpenTelemetry middleware outermost, keeping the server span
|
|
# active while response_headers writes the completed-request log.
|
|
setup_telemetry(app, engine)
|
|
|
|
|
|
@app.exception_handler(HTTPException)
|
|
async def http_exception_handler(request: Request, exc: HTTPException):
|
|
request_id = getattr(
|
|
request.state,
|
|
"request_id",
|
|
str(uuid.uuid4()),
|
|
)
|
|
|
|
code = {
|
|
400: "invalid_request",
|
|
401: "unauthorized",
|
|
404: "not_found",
|
|
409: "conflict",
|
|
413: "payload_too_large",
|
|
415: "unsupported_media_type",
|
|
429: "rate_limited",
|
|
500: "internal_error",
|
|
503: "unavailable",
|
|
}.get(exc.status_code, "internal_error")
|
|
|
|
headers = dict(exc.headers or {})
|
|
headers["X-Request-Id"] = request_id
|
|
headers["X-Instance-Id"] = settings.instance_id
|
|
|
|
return JSONResponse(
|
|
status_code=exc.status_code,
|
|
content={
|
|
"error": {
|
|
"code": code,
|
|
"message": (
|
|
exc.detail
|
|
if isinstance(exc.detail, str)
|
|
else "Request failed"
|
|
),
|
|
"request_id": request_id,
|
|
}
|
|
},
|
|
headers=headers,
|
|
)
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_exception_handler(
|
|
request: Request,
|
|
exc: RequestValidationError,
|
|
):
|
|
request_id = getattr(
|
|
request.state,
|
|
"request_id",
|
|
str(uuid.uuid4()),
|
|
)
|
|
|
|
return JSONResponse(
|
|
status_code=400,
|
|
content={
|
|
"error": {
|
|
"code": "invalid_request",
|
|
"message": "Validation error",
|
|
"request_id": request_id,
|
|
}
|
|
},
|
|
headers={
|
|
"X-Request-Id": request_id,
|
|
"X-Instance-Id": settings.instance_id,
|
|
},
|
|
)
|
|
|
|
|
|
@app.get("/health/live")
|
|
def liveness():
|
|
return {"status": "ok"}
|
|
|
|
|
|
DRAIN_FILE = Path("/tmp/api-draining")
|
|
|
|
|
|
@app.get("/health/ready")
|
|
def readiness():
|
|
if DRAIN_FILE.exists():
|
|
raise HTTPException(
|
|
status_code=503,
|
|
detail="Instance is draining",
|
|
)
|
|
|
|
try:
|
|
with engine.connect() as connection:
|
|
connection.execute(text("SELECT 1"))
|
|
|
|
s3_client().head_bucket(Bucket=settings.s3_bucket)
|
|
|
|
return {"status": "ok"}
|
|
|
|
except Exception:
|
|
logger.exception(
|
|
"PostgreSQL or S3 readiness check failed"
|
|
)
|
|
|
|
raise HTTPException(
|
|
status_code=503,
|
|
detail="Required storage unavailable",
|
|
) from None
|