forked from mtusi2026/mtusi2026lab2
172 lines
4.2 KiB
Python
172 lines
4.2 KiB
Python
import logging
|
|
from collections.abc import Mapping
|
|
from uuid import uuid4
|
|
|
|
from fastapi import FastAPI, Request
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
from sqlalchemy.exc import InterfaceError, OperationalError
|
|
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
|
|
from starlette.exceptions import HTTPException as StarletteHTTPException
|
|
|
|
from app.core.request_id import REQUEST_ID_HEADER
|
|
from app.errors.exceptions import ApiError, internal_error, unavailable
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _get_request_id(request: Request) -> str:
|
|
request_id = getattr(request.state, "request_id", None)
|
|
|
|
if request_id is None:
|
|
request_id = str(uuid4())
|
|
request.state.request_id = request_id
|
|
|
|
return request_id
|
|
|
|
|
|
def _build_response(
|
|
request: Request,
|
|
status_code: int,
|
|
code: str,
|
|
message: str,
|
|
headers: Mapping[str, str] | None = None,
|
|
) -> JSONResponse:
|
|
request_id = _get_request_id(request)
|
|
|
|
response_headers = {
|
|
**(headers or {}),
|
|
REQUEST_ID_HEADER: request_id,
|
|
}
|
|
|
|
body = {
|
|
"error": {
|
|
"code": code,
|
|
"message": message,
|
|
"request_id": request_id,
|
|
}
|
|
}
|
|
|
|
return JSONResponse(
|
|
status_code=status_code,
|
|
content=body,
|
|
headers=response_headers,
|
|
)
|
|
|
|
|
|
async def api_error_handler(
|
|
request: Request,
|
|
exc: Exception,
|
|
) -> JSONResponse:
|
|
assert isinstance(exc, ApiError)
|
|
|
|
return _build_response(
|
|
request,
|
|
exc.status_code,
|
|
exc.code,
|
|
exc.message,
|
|
exc.headers,
|
|
)
|
|
|
|
|
|
async def routing_error_handler(
|
|
request: Request,
|
|
exc: Exception,
|
|
) -> JSONResponse:
|
|
assert isinstance(exc, StarletteHTTPException)
|
|
|
|
if exc.status_code == 404:
|
|
return _build_response(
|
|
request,
|
|
404,
|
|
"not_found",
|
|
"Объект не найден",
|
|
exc.headers,
|
|
)
|
|
|
|
return _build_response(
|
|
request,
|
|
exc.status_code,
|
|
"invalid_request",
|
|
"Неверный запрос",
|
|
exc.headers,
|
|
)
|
|
|
|
|
|
async def validation_error_handler(
|
|
request: Request,
|
|
exc: Exception,
|
|
) -> JSONResponse:
|
|
assert isinstance(exc, RequestValidationError)
|
|
|
|
fields = sorted({".".join(map(str, error["loc"])) for error in exc.errors()})
|
|
message = "Неверный запрос"
|
|
|
|
if fields:
|
|
message = f"{message}: {', '.join(fields)}"
|
|
|
|
return _build_response(
|
|
request,
|
|
400,
|
|
"invalid_request",
|
|
message,
|
|
)
|
|
|
|
|
|
async def database_unavailable_handler(
|
|
request: Request,
|
|
exc: Exception,
|
|
) -> JSONResponse:
|
|
"""БД недоступна, оборвалась или исчерпан пул -> ограниченный 503.
|
|
|
|
Детали (хост, SQL, credentials) пишем только в лог, клиенту — общий текст.
|
|
"""
|
|
request_id = _get_request_id(request)
|
|
logger.error(
|
|
"Database unavailable request_id=%s: %s",
|
|
request_id,
|
|
type(exc).__name__,
|
|
exc_info=exc,
|
|
)
|
|
|
|
error = unavailable()
|
|
return _build_response(
|
|
request,
|
|
error.status_code,
|
|
error.code,
|
|
error.message,
|
|
{"Retry-After": "1"},
|
|
)
|
|
|
|
|
|
async def unhandled_error_handler(
|
|
request: Request,
|
|
exc: Exception,
|
|
) -> JSONResponse:
|
|
request_id = _get_request_id(request)
|
|
|
|
logger.error(
|
|
"Unhandled error request_id=%s",
|
|
request_id,
|
|
exc_info=exc,
|
|
)
|
|
|
|
error = internal_error()
|
|
|
|
return _build_response(
|
|
request,
|
|
error.status_code,
|
|
error.code,
|
|
error.message,
|
|
)
|
|
|
|
|
|
def register_exception_handlers(app: FastAPI) -> None:
|
|
app.add_exception_handler(ApiError, api_error_handler)
|
|
app.add_exception_handler(StarletteHTTPException, routing_error_handler)
|
|
app.add_exception_handler(RequestValidationError, validation_error_handler)
|
|
app.add_exception_handler(OperationalError, database_unavailable_handler)
|
|
app.add_exception_handler(InterfaceError, database_unavailable_handler)
|
|
app.add_exception_handler(PoolTimeoutError, database_unavailable_handler)
|
|
app.add_exception_handler(Exception, unhandled_error_handler)
|