feat(config): Add debug environment option and update service terminology

Author: Bit-Maximum

.pre-commit-config.yaml

@@ -28,7 +28,7 @@ repos:
           [
             "--fix",
             "--select=ALL",
-            "--ignore=RUF100,BLE001,COM812,ISC001,D100,D104,D105,D107,D205,D211,D212,E203,E266,ANN204,ANN401,S104,S602,ERA001,PGH003,PLR0913,TRY400,N803,N805,N815,UP046",
+            "--ignore=RUF100,BLE001,COM812,ISC001,D100,D104,D105,D107,D205,D211,D212,E203,E266,ANN204,ANN401,S104,S602,ERA001,PGH003,PLR0913,TRY400,N803,N805,N815,UP046,FBT001,FBT002",
             "--line-length=100",
           ]
       # Run the formatter.

app/__main__.py

@@ -36,7 +36,7 @@ def main() -> None:
     """Entrypoint of the application."""
     set_multiproc_dir()
     uvicorn.run(
-        "app.web.application:get_app",
+        "app.core.application:get_app",
         workers=settings.UVICORN_WORKERS_COUNT,
         host=settings.UVICORN_HOST,
         port=settings.UVICORN_PORT,

app/core/application.py

@@ -0,0 +1,92 @@
+import logging
+from pathlib import Path
+
+import sentry_sdk
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
+from fastapi.responses import ORJSONResponse
+from fastapi.staticfiles import StaticFiles
+from sentry_sdk.integrations.fastapi import FastApiIntegration
+from sentry_sdk.integrations.logging import LoggingIntegration
+from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
+
+from app.controller.api.router import api_router
+from app.controller.errors.exception_manager import manage_api_exceptions
+from app.core.config import settings
+from app.core.lifespan import lifespan_setup
+from app.core.logger import configure_logging
+
+APP_ROOT = Path(__file__).parent.parent
+
+
+def get_app() -> FastAPI:
+    """
+    Get FastAPI application.
+
+    This is the main constructor of an application.
+
+    :return: application.
+    """
+    configure_logging()
+    if settings.SENTRY_DSN and settings.ENVIRONMENT != "local":
+        # Enables sentry integration.
+        sentry_sdk.init(
+            dsn=settings.SENTRY_DSN,
+            send_client_reports=settings.SENTRY_ALLOW_BEACON_REPORTS,
+            traces_sample_rate=settings.SENTRY_TRACES_SAMPLE_RATE,
+            profiles_sample_rate=settings.SENTRY_PROFILES_SAMPLE_RATE,
+            environment=settings.ENVIRONMENT,
+            integrations=[
+                FastApiIntegration(transaction_style="endpoint"),
+                LoggingIntegration(
+                    level=logging.getLevelName(
+                        settings.LOG_LEVEL.value,
+                    ),
+                    event_level=logging.ERROR,
+                ),
+                SqlalchemyIntegration(),
+            ],
+            _experiments={"metrics": False},
+        )
+    app = FastAPI(
+        title=settings.PROJECT_NAME,
+        version=settings.API_VERSION,
+        description=settings.PROJECT_DESCRIPTION,
+        contact={
+            "name": settings.CONTACT_NAME,
+            "email": settings.CONTACT_EMAIL,
+        },
+        lifespan=lifespan_setup,
+        docs_url=f"{settings.API_BASE_PATH}/docs",
+        redoc_url=f"{settings.API_BASE_PATH}/redoc",
+        openapi_url=f"{settings.API_BASE_PATH}/openapi.json",
+        default_response_class=ORJSONResponse,
+    )
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[str(origin) for origin in settings.CORS_ORIGINS],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["X-Requested-With", "X-Request-ID", "Content-Type"],
+        expose_headers=["X-Request-ID"],
+    )
+
+    app.add_middleware(TrustedHostMiddleware, allowed_hosts=settings.ALLOWED_HOSTS)
+
+    # Main router for the API.
+    app.include_router(router=api_router, prefix=settings.API_BASE_PATH)
+
+    # Adds exceptions handler
+    manage_api_exceptions(app=app)
+
+    # Adds static directory.
+    # This directory is used to access swagger files.
+    app.mount(
+        f"{settings.API_BASE_PATH}",
+        StaticFiles(directory=APP_ROOT / "static"),
+        name="static",
+    )
+
+    return app

app/core/config.py

@@ -63,7 +63,7 @@ class Settings(BaseSettings):
     LOG_LEVEL: LogLevel = LogLevel.INFO
     LOG_FILE_PATH: str = "logs/app.log"
     USERS_SECRET: str = ""
-    ENVIRONMENT: Literal["local", "pytest", "staging", "production"] = "local"
+    ENVIRONMENT: Literal["debug", "local", "pytest", "staging", "production"] = "local"
     ## CORS_ORIGINS and ALLOWED_HOSTS are a JSON-formatted list of origins
     ## For example: ["http://localhost:4200", "https://myfrontendapp.com"]
     ALLOWED_HOSTS: list[str] = ["localhost", "127.0.0.1", "api.localhost"]
@@ -74,7 +74,7 @@ class Settings(BaseSettings):
     APP_VERSION: str = "latest"
     APP_HOST: str = "0.0.0.0"
 
-    # Docker services` hosts
+    # Docker adapters` hosts
     API_CONTAINER_HOST: str = "app-api"
     API_TASKIQ_CONTAINER_HOST: str = "api-taskiq"
     DB_CONTAINER_HOST: str = "app-db"

app/core/lifespan.py

@@ -0,0 +1,176 @@
+import os
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from loguru import logger
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.instrumentation.aio_pika import AioPikaInstrumentor
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from opentelemetry.instrumentation.redis import RedisInstrumentor
+from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
+from opentelemetry.sdk.resources import (
+    DEPLOYMENT_ENVIRONMENT,
+    SERVICE_NAME,
+    TELEMETRY_SDK_LANGUAGE,
+    Resource,
+)
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.trace import set_tracer_provider
+from prometheus_fastapi_instrumentator.instrumentation import (
+    PrometheusFastApiInstrumentator,
+)
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+
+from app.adapters.kafka.lifespan import init_kafka, shutdown_kafka
+from app.adapters.rabbit.lifespan import init_rabbit, shutdown_rabbit
+from app.adapters.redis.lifespan import init_redis, shutdown_redis
+from app.core.config import settings
+from app.core.tkq import broker
+
+
+def _setup_db(app: FastAPI) -> None:  # pragma: no cover
+    """
+    Creates connection to the database.
+
+    This function creates SQLAlchemy engine instance,
+    session_factory for creating sessions
+    and stores them in the application's state property.
+
+    :param app: fastAPI application.
+    """
+    engine = create_async_engine(str(settings.db_url), echo=settings.DB_ECHO)
+    session_factory = async_sessionmaker(
+        engine,
+        # See https://fastapi-users.github.io/fastapi-users/latest/configuration/databases/sqlalchemy/#asynchronous-driver
+        expire_on_commit=False,
+    )
+    app.state.db_engine = engine
+    app.state.db_session_factory = session_factory
+
+
+def setup_opentelemetry(app: FastAPI) -> None:  # pragma: no cover
+    """
+    Enables opentelemetry instrumentation.
+
+    :param app: current application.
+    """
+    if not settings.OPENTELEMETRY_ENDPOINT:
+        return
+
+    tracer_provider = TracerProvider(
+        resource=Resource(
+            attributes={
+                SERVICE_NAME: settings.API_CONTAINER_HOST,
+                TELEMETRY_SDK_LANGUAGE: "python",
+                DEPLOYMENT_ENVIRONMENT: settings.ENVIRONMENT,
+            },
+        ),
+    )
+
+    tracer_provider.add_span_processor(
+        BatchSpanProcessor(
+            OTLPSpanExporter(
+                endpoint=settings.OPENTELEMETRY_ENDPOINT,
+                insecure=True,
+            ),
+        ),
+    )
+
+    excluded_endpoints = [
+        app.url_path_for("health_check"),
+        app.url_path_for("openapi"),
+        app.url_path_for("swagger_ui_html"),
+        app.url_path_for("swagger_ui_redirect"),
+        app.url_path_for("redoc_html"),
+        "/metrics",
+    ]
+
+    FastAPIInstrumentor().instrument_app(
+        app,
+        tracer_provider=tracer_provider,
+        excluded_urls=",".join(excluded_endpoints),
+    )
+    RedisInstrumentor().instrument(
+        tracer_provider=tracer_provider,
+    )
+    SQLAlchemyInstrumentor().instrument(
+        tracer_provider=tracer_provider,
+        engine=app.state.db_engine.sync_engine,
+    )
+    AioPikaInstrumentor().instrument(
+        tracer_provider=tracer_provider,
+    )
+
+    set_tracer_provider(tracer_provider=tracer_provider)
+
+
+def stop_opentelemetry(app: FastAPI) -> None:  # pragma: no cover
+    """
+    Disables opentelemetry instrumentation.
+
+    :param app: current application.
+    """
+    if not settings.OPENTELEMETRY_ENDPOINT:
+        return
+
+    FastAPIInstrumentor().uninstrument_app(app)
+    RedisInstrumentor().uninstrument()
+    SQLAlchemyInstrumentor().uninstrument()
+    AioPikaInstrumentor().uninstrument()
+
+
+def setup_prometheus(app: FastAPI) -> None:  # pragma: no cover
+    """
+    Enables prometheus integration.
+
+    :param app: current application.
+    """
+    PrometheusFastApiInstrumentator(should_group_status_codes=False).instrument(
+        app,
+    ).expose(app, should_gzip=True, name="prometheus_metrics")
+
+
+@asynccontextmanager
+async def lifespan_setup(
+    app: FastAPI,
+) -> AsyncGenerator[None]:  # pragma: no cover
+    """
+    Actions to run on application startup.
+
+    This function uses fastAPI app to store data
+    in the state, such as db_engine.
+
+    :param app: the fastAPI application.
+    :return: function that actually performs actions.
+    """
+    app.middleware_stack = None
+    if not broker.is_worker_process:
+        await broker.startup()
+    _setup_db(app)
+    setup_opentelemetry(app)
+    init_redis(app)
+    init_rabbit(app)
+    await init_kafka(app)
+    setup_prometheus(app)
+    app.middleware_stack = app.build_middleware_stack()
+
+    logger.debug("Debug log")
+    logger.info("Info log with cid + tracing")
+    logger.warning("Warning log")
+    logger.error("Error log")
+    logger.critical("Critical log")
+
+    logger.info(os.environ)
+    logger.info(app.routes)
+
+    yield
+    if not broker.is_worker_process:
+        await broker.shutdown()
+    await app.state.db_engine.dispose()
+
+    await shutdown_redis(app)
+    await shutdown_rabbit(app)
+    await shutdown_kafka(app)
+    stop_opentelemetry(app)

app/core/tkq.py

@@ -19,5 +19,5 @@
 
 taskiq_fastapi.init(
     broker,
-    "app.web.application:get_app",
+    "app.controller.application:get_app",
 )