Files
mtusi2026lab7/src/app/main.py
T

296 lines
12 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import logging
import os
import signal
import sys
import time
import uuid
from contextlib import asynccontextmanager
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.openapi.utils import get_openapi
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
import psycopg
import uvicorn
from opentelemetry import trace as _otel_trace
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from .api import attachments, auth, chats, health, messages, users
from .storage.db import init_pool, close_pool
from .telemetry import init_telemetry, INSTANCE_ID, meter, tracer
# Базовый логгер: реальный формат выставляет telemetry.install_log_format()
# при вызове init_telemetry(). Здесь — минимальный fallback для импорта.
logging.basicConfig(level=logging.INFO, stream=sys.stdout)
logger = logging.getLogger("app")
MAX_REQUEST_BODY_BYTES = int(os.environ.get("MAX_REQUEST_BODY_BYTES", "10485760"))
@asynccontextmanager
async def lifespan(app: FastAPI):
init_pool()
logger.info(
"event=startup app_env=%s session_store=%s instance_id=%s",
os.environ.get("APP_ENV", "lab"),
os.environ.get("SESSION_STORE", "postgres"),
INSTANCE_ID,
)
yield
close_pool()
logger.info("event=shutdown_complete instance_id=%s", INSTANCE_ID)
app = FastAPI(
title="MTUCI Messenger — lab6",
version="1.6.0",
lifespan=lifespan,
swagger_ui_parameters={"persistAuthorization": True},
)
# OTel инициализация и FastAPI auto-instrumentation.
init_telemetry("messenger-api", "1.6.0")
# --- Метрики HTTP ---
_http_counter = meter("messenger").create_counter(
"http_requests_total",
description="HTTP requests count",
unit="1",
)
# Явные границы бакетов в СЕКУНДАХ, с разрешением в миллисекундном диапазоне
# и вокруг порога SLO 2s (upload p95 alert). Дефолтные экспоненциальные
# бакеты (0, 5, 10, 25, …) грубы: миллисекундные запросы попадали в один
# широкий bucket, а histogram_quantile интерполировал ложные секунды.
_HTTP_DURATION_BUCKETS = [
0.001, 0.0025, 0.005, 0.0075, 0.01, 0.015, 0.02, 0.03, 0.05,
0.075, 0.1, 0.15, 0.2, 0.3, 0.5, 0.75, 1.0, 1.5, 2.0, 3.0, 5.0, 10.0,
]
_http_hist = meter("messenger").create_histogram(
"http_request_duration_seconds",
description="HTTP request duration",
unit="s",
explicit_bucket_boundaries_advisory=_HTTP_DURATION_BUCKETS,
)
# Фильтр: убираем реальные UUID из маршрута → route template.
import re as _re
_ROUTE_UUID_RE = _re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
def _route_template(path: str) -> str:
return _ROUTE_UUID_RE.sub("{id}", path)
def custom_openapi():
if app.openapi_schema:
return app.openapi_schema
schema = get_openapi(title=app.title, version=app.version, routes=app.routes)
app.openapi_schema = schema
return schema
app.openapi = custom_openapi
# Отдельный tracer для событийного span в middleware. Он создаётся как child
# SERVER span, который создаёт OTel FastAPI instrumentation ниже.
# ВАЖНО: FastAPIInstrumentor.instrument_app(app) вызывается ПОСЛЕ объявления
# middleware, поэтому OTel ASGI middleware оказывается внешним: он извлекает
# W3C traceparent из входящих headers, продолжает внешний trace и создаёт
# SERVER span. Наш middleware выполняется внутри него, создаёт http.request
# как INTERNAL child, и логи/метрики берут корректный trace_id.
_http_tracer = tracer("app.http")
@app.middleware("http")
async def observability_middleware(request: Request, call_next):
"""X-Request-Id и X-Instance-Id во всех ответах + структурированный лог + метрики.
Лог event=http пишется ВНУТРИ активного span (`http.request`), он
child SERVER span от OTel auto-instrumentation, поэтому trace_id
корректно связывает лог с внешним trace.
"""
request_id = request.headers.get("X-Request-Id") or uuid.uuid4().hex
request.state.request_id = request_id
started = time.monotonic()
route = _route_template(request.url.path)
# lab7: раннее ограничение размера запроса (Content-Length).
cl = request.headers.get("content-length")
if cl is not None:
try:
if int(cl) > MAX_REQUEST_BODY_BYTES:
response = JSONResponse(
status_code=413,
content={"error": {"code": "payload_too_large",
"message": "payload_too_large",
"request_id": request_id}},
headers={"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID},
)
return response
except ValueError:
pass
# http.request — INTERNAL child текущего (SERVER) span, созданного OTel
# auto-instrumentation. Parent берётся из активного контекста: входящий
# traceparent уже извлечён ASGI middleware.
with _http_tracer.start_as_current_span(
"http.request",
attributes={
"http.method": request.method,
"http.route": route,
},
) as span:
response = await call_next(request)
duration_s = time.monotonic() - started
duration_ms = round(duration_s * 1000, 2)
status_class = "%dxx" % (response.status_code // 100)
response.headers["X-Request-Id"] = request_id
response.headers["X-Instance-Id"] = INSTANCE_ID
_http_counter.add(
1,
{"http.method": request.method, "http.route": route,
"http.status_class": status_class},
)
_http_hist.record(
duration_s,
{"http.method": request.method, "http.route": route,
"http.status_class": status_class},
)
span.set_attribute("http.status_class", status_class)
span.set_attribute("http.status_code", response.status_code)
# Лог ВНУТРИ span → record.trace_id валидный, Loki получает
# корреляцию с Tempo.
logger.info(
"event=http method=%s path=%s status=%s duration_ms=%s "
"request_id=%s instance_id=%s",
request.method, request.url.path, response.status_code,
duration_ms, request_id, INSTANCE_ID,
)
return response
# FastAPI auto-instrumentation ДОЛЖНА быть установлена ПОСЛЕ пользовательского
# @app.middleware("http"), чтобы оказаться внешним middleware и создать SERVER
# span с корректным parent из входного traceparent. Этот вызов также
# инструментирует httpx/requests client-вызовы внутри приложения.
FastAPIInstrumentor.instrument_app(app)
# --- Обработчики ошибок (без изменений) ---
_ERROR_CODES = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
503: "unavailable",
500: "internal_error",
}
def _unauthorized_challenge(path: str) -> str:
if path == "/api/v1/auth/sessions":
return 'Basic realm="messenger", charset="UTF-8"'
return 'Bearer realm="messenger"'
def _error_response(status_code: int, message: str, request_id: str,
path: str = "", extra_headers: dict | None = None) -> JSONResponse:
code = _ERROR_CODES.get(status_code, "internal_error")
headers = {}
if status_code == 401:
headers["WWW-Authenticate"] = _unauthorized_challenge(path)
# lab7: пробрасываем заголовки из HTTPException (например, Retry-After у 429).
if extra_headers:
headers.update(extra_headers)
headers["X-Request-Id"] = request_id
headers["X-Instance-Id"] = INSTANCE_ID
return JSONResponse(
status_code=status_code,
content={"error": {"code": code, "message": message, "request_id": request_id}},
headers=headers,
)
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
message = exc.detail if isinstance(exc.detail, str) else "Ошибка"
# lab7: сохраняем заголовки, установленные в HTTPException (Retry-After и т.п.).
return _error_response(exc.status_code, message, request_id, request.url.path,
extra_headers=dict(exc.headers or {}))
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
return _error_response(400, "Неверный запрос", request_id, request.url.path)
@app.exception_handler(psycopg.OperationalError)
async def db_unavailable_handler(request: Request, exc: psycopg.OperationalError):
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
logger.error("event=db_unavailable type=%s request_id=%s",
type(exc).__name__, request_id)
return _error_response(503, "Зависимость недоступна", request_id, request.url.path)
@app.exception_handler(RuntimeError)
async def runtime_error_handler(request: Request, exc: RuntimeError):
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
text = str(exc)
if "db_unavailable" in text:
logger.error("event=db_unavailable request_id=%s", request_id)
return _error_response(503, "Зависимость недоступна", request_id, request.url.path)
if "redis_unavailable" in text:
logger.error("event=redis_unavailable request_id=%s", request_id)
return _error_response(503, "Зависимость недоступна", request_id, request.url.path)
if "s3_unavailable" in text:
logger.error("event=s3_unavailable request_id=%s", request_id)
return _error_response(503, "Зависимость недоступна", request_id, request.url.path)
logger.error("event=runtime_error type=%s request_id=%s",
type(exc).__name__, request_id)
return _error_response(500, "Внутренняя ошибка", request_id, request.url.path)
@app.exception_handler(Exception)
async def unhandled_exception_handler(request: Request, exc: Exception):
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
logger.error("event=unhandled_exception type=%s request_id=%s",
type(exc).__name__, request_id)
return _error_response(500, "Внутренняя ошибка", request_id, request.url.path)
app.include_router(health.router)
app.include_router(auth.router)
app.include_router(users.router)
app.include_router(chats.router)
app.include_router(messages.router)
app.include_router(attachments.router)
if __name__ == "__main__":
config = uvicorn.Config(
"app.main:app",
host="0.0.0.0",
port=8080,
log_level="info",
ssl_ca_certs=os.environ.get("TLS_CA_FILE"),
ssl_certfile=os.environ.get("TLS_CERT_FILE"),
ssl_keyfile=os.environ.get("TLS_KEY_FILE"),
ssl_cert_reqs=int(os.environ.get("MTLS_REQUIRE", "0")), # 2 = CERT_REQUIRED
)
server = uvicorn.Server(config)
def _handle_sigterm(signum, frame):
logger.info("event=sigterm_received signal=%s", signum)
server.should_exit = True
signal.signal(signal.SIGTERM, _handle_sigterm)
server.run()