add stacks like Prometheus and Sentry to monitoring app

Author: RustamovAkrom

pyproject.toml

@@ -21,6 +21,7 @@ dependencies = [
     "orjson>=3.11.4",
     "passlib[bcrypt]>=1.7.4",
     "pre-commit>=4.5.0",
+    "prometheus-fastapi-instrumentator>=7.1.0",
     "psycopg-binary>=3.2.13",
     "pydantic-settings>=2.12.0",
     "pydantic[email]>=2.12.5",
@@ -31,6 +32,7 @@ dependencies = [
     "python-jose[cryptography]>=3.5.0",
     "python-multipart>=0.0.20",
     "ruff>=0.14.7",
+    "sentry-sdk>=2.47.0",
     "types-python-jose>=3.5.0.20250531",
     "uvicorn[standard]>=0.38.0",
 ]

src/app.py

@@ -1,35 +1,44 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import ORJSONResponse
+from fastapi.staticfiles import StaticFiles
 
 from api.routers import api_router
-from core.config import settings
+from core.config import MEDIA_ROOT, MEDIA_URL, settings
 from core.exceptions import register_error_handler
 from core.lifespan import lifespan
 from core.logger import configure_logger
+from core.monitoring import router as monitoring_router
+from core.prometheus import MetricsMiddleware
+from core.sentry import init_sentry
+from middlewares.request_id_middleware import RequestIDMiddleware
 
 
 def create_app() -> FastAPI:
     """Create and configure the FastAPI application."""
+    # Configure logger
+    configure_logger()
+
+    # Initialize Sentry (if configured)
+    init_sentry()
+
     app = FastAPI(
         title=settings.APP_NAME,
         version=settings.APP_VERSION,
         description=settings.APP_DESCRIPTION,
         lifespan=lifespan,
         docs_url="/docs" if settings.ENV != "prod" else None,
         redoc_url="/redoc" if settings.ENV != "prod" else None,
+        swagger_ui_parameters={"defaultModelsExpandDepth": -1},
         openapi_url="/openapi.json" if settings.ENV != "prod" else None,
         default_response_class=ORJSONResponse,
     )
+    # Request ID middleware (must be first)
+    app.add_middleware(RequestIDMiddleware)
 
-    # Configure logger
-    configure_logger()
-
-    # Register exception handlers
-    register_error_handler(app)
-
-    # Include API router
-    app.include_router(api_router, prefix="/api/v1")
+    # Only add metrics middleware in environments where Prometheus scraping is expected
+    if settings.PROMETHEUS_ENABLED:
+        app.add_middleware(MetricsMiddleware)
 
     # Set up CORS middleware
     app.add_middleware(
@@ -40,4 +49,20 @@ def create_app() -> FastAPI:
         allow_headers=["*"],
     )
 
+    # Include routers
+    app.include_router(api_router, prefix="/api/v1")
+    app.include_router(router=monitoring_router)  # /monitoring/*
+
+    # Register error handlers
+    register_error_handler(app)
+
+    # Include API router
+
+    # Static files (media)
+    try:
+        app.mount(MEDIA_URL, StaticFiles(directory=MEDIA_ROOT), name="media")
+    except Exception:
+        # don't crash if media doesn't exists at startup
+        pass
+
     return app

src/core/config.py

@@ -44,8 +44,10 @@ class BaseAppSettings(BaseSettings):
 
     @property
     def DATABASE_URL(self) -> str:
-        if self.ENV == "dev":
-            return f"sqlite+aiosqlite:///{BASE_DIR / self.DB_NAME}.db"
+        if self.ENV == "dev" or self.DB_ENGINE == "sqlite":
+            db_path = BASE_DIR / f"{self.DB_NAME}.db"
+            return f"sqlite+aiosqlite:///{db_path}"
+        # Postgres
         return (
             "postgresql+asyncpg://"
             f"{self.DB_USER}:{self.DB_PASSWORD}@"
@@ -69,7 +71,7 @@ def DATABASE_URL(self) -> str:
     def CELERY_BROKER_URL(self):
         if self.BROKER == "redis":
             return f"redis://{self.REDIS_HOST}:{self.REDIS_PORT}/{self.REDIS_DB}"
-
+        # rabbitmq
         return (
             "amqp://"
             f"{self.RABBITMQ_USER}:{self.RABBITMQ_PASSWORD}"
@@ -108,6 +110,14 @@ def OAUTH_PROVIDERS(self):
             }
         }
 
+    # Sentry DSN
+    SENTRY_DSN: str | None = None
+
+    # Prometheus
+    PROMETHEUS_ENABLED: bool = True
+    PROMETHEUS_PATH: str = "/metrics"
+    PROMETHEUS_METRICS_KEY: str = "secret"
+
     # Pydantic config
     model_config = SettingsConfigDict(
         validate_assignment=True,

src/core/database.py

@@ -12,9 +12,12 @@
 
 @cache
 def get_async_db_engine() -> AsyncEngine:
+    url = settings.DATABASE_URL
+    if not url:
+        raise RuntimeError("DATABASE_URL is not configured")
     return create_async_engine(
-        settings.DATABASE_URL,
-        echo=settings.ENV == "dev",
+        url,
+        echo=(settings.ENV == "dev"),
         future=True,
     )
 

src/core/monitoring.py

@@ -0,0 +1,60 @@
+# src/core/monitoring.py
+import time
+from typing import Annotated
+
+from fastapi import APIRouter, Header, Response
+from prometheus_client import CONTENT_TYPE_LATEST, REGISTRY, generate_latest
+from pydantic import BaseModel
+
+from core.config import settings
+
+router = APIRouter(prefix="/monitoring", tags=["monitoring"])
+
+
+class HealthcheckResponse(BaseModel):
+    timestamp: int
+
+
+class StatusResponse(BaseModel):
+    app: str = "ok"
+
+
+class VersionResponse(BaseModel):
+    version: str
+
+
+@router.get("/healthcheck", summary="Проверить доступность сервиса")
+def ping() -> HealthcheckResponse:
+    return HealthcheckResponse(timestamp=int(time.time()))
+
+
+@router.get("/status", summary="Проверить статус используемых сервисов")
+async def status() -> StatusResponse:
+    # optionally add DB/Redis checks here (non-blocking or with timeout)
+    return StatusResponse()
+
+
+@router.get("/version", summary="Проверить версию приложения")
+def get_version() -> VersionResponse:
+    # safe fallback if package not installed
+    try:
+        ver = settings.APP_VERSION
+    except Exception:
+        ver = "unknown"
+    return VersionResponse(version=ver)
+
+
+@router.get("/metrics", summary="Получить метрики Prometheus", include_in_schema=False)
+async def metrics(key: Annotated[str | None, Header()] = None) -> Response:
+    """
+    Protected exposition of Prometheus metrics.
+    By default requires header 'X-Prometheus-Key' == settings.prometheus_metrics_key.
+    In debug/local you can allow empty key by setting prometheus_metrics_key to empty string.
+    """
+    # header name from client is 'X-Prometheus-Key'
+    expected = settings.PROMETHEUS_METRICS_KEY or ""
+    if expected and key != expected:
+        return Response(status_code=403)
+
+    data = generate_latest(REGISTRY)
+    return Response(content=data, media_type=CONTENT_TYPE_LATEST)

src/core/prometheus.py

@@ -0,0 +1,96 @@
+import time
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from functools import cache
+
+from fastapi import Request, Response
+from prometheus_client import Counter, Gauge, Histogram
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from core.config import settings
+
+
+@dataclass
+class Metrics:
+    request_count: Counter
+    request_latency: Histogram
+    inprogress_requests: Gauge
+
+
+@cache
+def get_metrics() -> Metrics:
+    prefix = settings.APP_NAME.replace("-", "_")
+    # Use a didicated registry via default REGISTRY, okay for most setups.
+    return Metrics(
+        request_count=Counter(
+            f"{prefix}_http_requests_total",
+            "Total number of HTTP requests",
+            ["method", "endpoint", "status_code"],
+        ),
+        request_latency=Histogram(
+            f"{prefix}_http_request_duration_seconds",
+            "HTTP request latency (seconds)",
+            ["method", "endpoint", "status_code"],
+            buckets=(0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0),
+        ),
+        inprogress_requests=Gauge(
+            f"{prefix}_inprogress_requests",
+            "Number of in-progress requests",
+            ["endpoint"],
+        ),
+    )
+
+
+def _get_route_path(request: Request) -> str:
+    """
+    Return the route template path if available (e.g. "/api/users/{user_id}"),
+    otherwise fallback to raw path (but avoid querystring).
+    """
+    route = request.scope.get("route")
+    try:
+        # Starlette/fastapi Route has .path attribute
+        if hasattr(route, "path"):
+            return route.path  # type: ignore
+    except Exception:
+        pass
+    # Fallback: use the raw path but strip any high-cardinality parts carefully
+    return request.url.path
+
+
+class MetricsMiddleware(BaseHTTPMiddleware):
+    async def dispatch(
+        self,
+        request: Request,
+        call_next: Callable[[Request], Awaitable[Response]],
+    ) -> Response:
+
+        # Do not collect for non-api or static endpoints (configurable)
+        path = request.url.path
+        if not path.startswith("/api"):
+            return await call_next(request)
+
+        metrics = get_metrics()
+        endpoint = _get_route_path(request)
+
+        # inprogress gauge
+        metrics.inprogress_requests.labels(endpoint=endpoint).inc()
+        start_time = time.time()
+
+        try:
+            response = await call_next(request)
+        finally:
+            # always decrement even on exceptions
+            metrics.inprogress_requests.labels(endpoint=endpoint).dec()
+
+        process_time = time.time() - start_time
+        status = getattr(response, "status_code", 500)
+
+        labels = {
+            "method": request.method,
+            "endpoint": endpoint,
+            "status_code": str(status),
+        }
+        metrics.request_count.labels(**labels).inc()
+        metrics.request_latency.labels(**labels).observe(process_time)
+
+        return response

src/core/sentry.py

@@ -0,0 +1,33 @@
+# src/core/sentry.py
+import logging
+
+from sentry_sdk import init as sentry_init
+from sentry_sdk.integrations.fastapi import FastApiIntegration
+from sentry_sdk.integrations.redis import RedisIntegration
+from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
+
+from core.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+def init_sentry() -> None:
+    dsn = settings.SENTRY_DSN
+    if not dsn:
+        logger.info("Sentry DSN not provided — skipping Sentry init")
+        return
+
+    sentry_init(
+        dsn=dsn,
+        environment=settings.ENV,
+        integrations=[
+            FastApiIntegration(),
+            SqlalchemyIntegration(),
+            RedisIntegration(),
+        ],
+        traces_sample_rate=0.1 if settings.ENV == "prod" else 0.5,
+        profiles_sample_rate=0.0 if settings.ENV == "dev" else 0.01,
+        send_default_pii=False,  # avoid leaking user PII by default
+        debug=False,
+    )
+    logger.info("Sentry initialized")

src/main.py

@@ -1,11 +1,14 @@
 import uvicorn
 
+from app import create_app
 from core.config import settings
 
 if __name__ == "__main__":
+    app = create_app()
+
     uvicorn.run(
-        "app:create_app",
+        app=app,
         host=settings.SERVER_HOST,
         port=settings.SERVER_PORT,
-        reload=settings.RELOAD,
+        reload=settings.RELOAD and settings.ENV == "dev",
     )

src/middlewares/__init__.py

@@ -0,0 +1,17 @@
+import uuid
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import Response
+
+REQUEST_ID_HEADER = "X-Request-ID"
+
+
+class RequestIDMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request, call_next):
+        request_id = request.headers.get(REQUEST_ID_HEADER) or str(uuid.uuid4())
+        # attach to scope for latter usage
+        request.state.request_id = request_id
+
+        response: Response = await call_next(request)
+        response.headers[REQUEST_ID_HEADER] = request_id
+        return response