fixed broken tests

Author: Andrei Neagu

services/notifications/src/simcore_service_notifications/api/rpc/routing.py

@@ -12,7 +12,7 @@
 ]
 
 
-async def lifespan_rpc_api_routes(app: FastAPI) -> AsyncIterator[State]:
+async def rpc_api_routes_lifespan(app: FastAPI) -> AsyncIterator[State]:
     rpc_server = get_rabbitmq_rpc_server(app)
 
     for router in ROUTERS:

services/notifications/src/simcore_service_notifications/core/application.py

@@ -1,28 +1,19 @@
 import logging
-from collections.abc import AsyncIterator
 
 from fastapi import FastAPI
-from fastapi_lifespan_manager import State
-from servicelib.fastapi.lifespan_utils import LifespanGenerator, combine_lifespans
 from servicelib.fastapi.openapi import (
     get_common_oas_options,
     override_fastapi_openapi_method,
 )
+from servicelib.fastapi.prometheus_instrumentation import (
+    initialize_prometheus_instrumentation,
+)
 from servicelib.fastapi.tracing import initialize_tracing
 from servicelib.logging_utils import config_all_loggers
 
-from .._meta import (
-    API_VTAG,
-    APP_FINISHED_BANNER_MSG,
-    APP_NAME,
-    APP_STARTED_BANNER_MSG,
-    SUMMARY,
-    VERSION,
-)
+from .._meta import API_VTAG, APP_NAME, SUMMARY, VERSION
 from ..api.rest.routing import initialize_rest_api
-from ..api.rpc.routing import lifespan_rpc_api_routes
-from ..services.postgres.service import lifespan_postgres
-from ..services.rabbitmq import lifespan_rabbitmq
+from . import events
 from .settings import ApplicationSettings
 
 _logger = logging.getLogger(__name__)
@@ -39,40 +30,30 @@ def _initialise_logger(settings: ApplicationSettings):
     )
 
 
-async def _lifespan_banner(app: FastAPI) -> AsyncIterator[State]:
-    _ = app
-    print(APP_STARTED_BANNER_MSG, flush=True)  # noqa: T201
-    yield {}
-    print(APP_FINISHED_BANNER_MSG, flush=True)  # noqa: T201
-
-
 def create_app() -> FastAPI:
     settings = ApplicationSettings.create_from_envs()
     _logger.debug(settings.model_dump_json(indent=2))
 
     _initialise_logger(settings)
 
-    lifespans: list[LifespanGenerator] = [
-        lifespan_rabbitmq,
-        lifespan_postgres,
-        lifespan_rpc_api_routes,
-    ]
-
     assert settings.SC_BOOT_MODE  # nosec
     app = FastAPI(
         debug=settings.SC_BOOT_MODE.is_devel_mode(),
         title=APP_NAME,
         description=SUMMARY,
         version=f"{VERSION}",
         openapi_url=f"/api/{API_VTAG}/openapi.json",
-        lifespan=combine_lifespans(*lifespans, _lifespan_banner),
+        lifespan=events.create_app_lifespan(),
         **get_common_oas_options(is_devel_mode=settings.SC_BOOT_MODE.is_devel_mode()),
     )
     override_fastapi_openapi_method(app)
     app.state.settings = settings
 
     initialize_rest_api(app)
 
+    if settings.NOTIFICATIONS_PROMETHEUS_INSTRUMENTATION_ENABLED:
+        initialize_prometheus_instrumentation(app)
+
     if settings.NOTIFICATIONS_TRACING:
         initialize_tracing(app, settings.NOTIFICATIONS_TRACING, APP_NAME)
 

services/notifications/src/simcore_service_notifications/core/events.py

@@ -0,0 +1,63 @@
+from collections.abc import AsyncIterator
+
+from fastapi import FastAPI
+from fastapi_lifespan_manager import LifespanManager, State
+from servicelib.fastapi.postgres_lifespan import (
+    PostgresLifespanState,
+    postgres_database_lifespan,
+)
+from servicelib.fastapi.prometheus_instrumentation import (
+    lifespan_prometheus_instrumentation,
+)
+
+from .._meta import APP_FINISHED_BANNER_MSG, APP_STARTED_BANNER_MSG
+from ..api.rpc.routing import rpc_api_routes_lifespan
+from ..services.postgres import postgres_lifespan
+from ..services.rabbitmq import rabbitmq_lifespan
+from .settings import ApplicationSettings
+
+
+async def _banner_lifespan(app: FastAPI) -> AsyncIterator[State]:
+    _ = app
+    print(APP_STARTED_BANNER_MSG, flush=True)  # noqa: T201
+    yield {}
+    print(APP_FINISHED_BANNER_MSG, flush=True)  # noqa: T201
+
+
+async def _main_lifespan(app: FastAPI) -> AsyncIterator[State]:
+    settings: ApplicationSettings = app.state.settings
+    yield {
+        PostgresLifespanState.POSTGRES_SETTINGS: settings.NOTIFICATIONS_POSTGRES,
+        "prometheus_instrumentation_enabled": settings.NOTIFICATIONS_PROMETHEUS_INSTRUMENTATION_ENABLED,
+    }
+
+
+async def _prometheus_instrumentation_lifespan(  # TODO: put this into one single setup like we did for the DB
+    app: FastAPI, state: State
+) -> AsyncIterator[State]:
+    if state.get("prometheus_instrumentation_enabled", False):
+        async for prometheus_state in lifespan_prometheus_instrumentation(app):
+            yield prometheus_state
+
+
+def create_app_lifespan():
+    # WARNING: order matters
+    app_lifespan = LifespanManager()
+    app_lifespan.add(_main_lifespan)
+
+    # - postgres
+    app_lifespan.add(postgres_database_lifespan)
+    app_lifespan.add(postgres_lifespan)
+
+    # - rabbitmq
+    app_lifespan.add(rabbitmq_lifespan)
+
+    # - rpc api routes
+    app_lifespan.add(rpc_api_routes_lifespan)
+
+    # - prometheus instrumentation
+    app_lifespan.add(_prometheus_instrumentation_lifespan)
+
+    app_lifespan.add(_banner_lifespan)
+
+    return app_lifespan

services/notifications/src/simcore_service_notifications/core/settings.py

@@ -73,6 +73,8 @@ class ApplicationSettings(BaseCustomSettings, MixinLoggingSettings):
         ),
     ]
 
+    NOTIFICATIONS_PROMETHEUS_INSTRUMENTATION_ENABLED: bool = True
+
     @field_validator("LOG_LEVEL")
     @classmethod
     def valid_log_level(cls, value) -> LogLevel:

services/notifications/src/simcore_service_notifications/services/postgres/__init__.py

@@ -7,6 +7,7 @@
     close_db_connection,
     connect_to_db,
 )
+from servicelib.fastapi.postgres_lifespan import PostgresLifespanState
 from servicelib.logging_utils import log_context
 
 from ...core.settings import ApplicationSettings
@@ -15,7 +16,9 @@
 _logger = logging.getLogger(__name__)
 
 
-async def lifespan_postgres(app: FastAPI) -> AsyncIterator[State]:
+async def postgres_lifespan(app: FastAPI, state: State) -> AsyncIterator[State]:
+    app.state.engine = state[PostgresLifespanState.POSTGRES_ASYNC_ENGINE]
+
     settings: ApplicationSettings = app.state.settings
 
     app.state.postgress_liveness = PostgresHealth(app)

services/notifications/src/simcore_service_notifications/services/rabbitmq.py

@@ -9,7 +9,7 @@
 from ..core.settings import ApplicationSettings
 
 
-async def lifespan_rabbitmq(app: FastAPI) -> AsyncIterator[State]:
+async def rabbitmq_lifespan(app: FastAPI) -> AsyncIterator[State]:
     settings: ApplicationSettings = app.state.settings
     rabbit_settings: RabbitSettings = settings.NOTIFICATIONS_RABBITMQ
     app.state.rabbitmq_rpc_server = None

services/notifications/tests/unit/conftest.py

@@ -4,6 +4,7 @@
 from collections.abc import AsyncIterator
 
 import pytest
+import sqlalchemy as sa
 from asgi_lifespan import LifespanManager
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
@@ -17,6 +18,7 @@ def service_env(
     monkeypatch: pytest.MonkeyPatch,
     mock_environment: EnvVarsDict,
     rabbit_service: RabbitSettings,
+    postgres_db: sa.engine.Engine,
     postgres_env_vars_dict: EnvVarsDict,
 ) -> EnvVarsDict:
     return setenvs_from_dict(