Full refactoring.

microbootstrap/bootstrap.py

@@ -1,64 +1,13 @@
 from __future__ import annotations
-import contextlib
 import typing
 
 
 if typing.TYPE_CHECKING:
     import granian
 
-    from microbootstrap.helpers import base as helpers_base
     from microbootstrap.settings.base import BootstrapSettings
 
 
-def bootstrap(
-    web_framework: type[
-        helpers_base.BootstrapWebFrameworkBootstrapper[
-            helpers_base.Application_contra,
-            helpers_base.Settings_contra,
-            helpers_base.ReturnType_co,
-        ]
-    ],
-    settings: helpers_base.Settings_contra,
-    app: helpers_base.Application_contra,
-) -> helpers_base.ReturnType_co:
-    web_framework_bootstrapper = web_framework()
-    web_framework_bootstrapper.load_parameters(app=app, settings=settings)
-    return web_framework_bootstrapper.initialize()
-
-
-def teardown(
-    web_framework: type[
-        helpers_base.BootstrapWebFrameworkBootstrapper[
-            helpers_base.Application_contra,
-            helpers_base.Settings_contra,
-            helpers_base.ReturnType_co,
-        ]
-    ],
-    settings: helpers_base.Settings_contra,
-    app: helpers_base.Application_contra,
-) -> None:
-    web_framework_bootstrapper = web_framework()
-    web_framework_bootstrapper.load_parameters(app=app, settings=settings)
-    web_framework_bootstrapper.teardown()
-
-
-@contextlib.contextmanager
-def enter_bootstrapper_context(
-    *bootstrapper_classes: type[helpers_base.BootstrapServicesBootstrapper[helpers_base.Settings_contra]],
-    settings: helpers_base.Settings_contra,
-) -> typing.Iterator[None]:
-    bootstrappers: typing.Final[list[helpers_base.BootstrapServicesBootstrapper[helpers_base.Settings_contra]]] = []
-    for one_class in bootstrapper_classes:
-        instance = one_class()
-        instance.load_parameters(settings)
-        instance.initialize()
-        bootstrappers.append(instance)
-
-    yield
-    for one_bootstrapper in bootstrappers:
-        one_bootstrapper.teardown()
-
-
 def create_granian_server(
     target: str,
     settings: BootstrapSettings,

microbootstrap/bootstrappers/base.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+import dataclasses
+import typing
+
+from microbootstrap.helpers import dataclass_to_dict_no_defaults, merge_dataclasses_configs, merge_dict_configs
+from microbootstrap.instruments import OpentelemetryInstrumentConfig, SentryInstrumentConfig
+
+
+if typing.TYPE_CHECKING:
+    from microbootstrap.instruments import Instrument
+    from microbootstrap.settings.base import BootstrapSettings
+
+
+ApplicationT = typing.TypeVar("ApplicationT")
+SettingsT = typing.TypeVar("SettingsT", bound="BootstrapSettings")
+SelfT = typing.TypeVar("SelfT", bound="ApplicationBootstrapper[typing.Any, typing.Any, typing.Any]")
+
+
+@dataclasses.dataclass()
+class ApplicationBootstrapper(typing.Protocol[SettingsT, ApplicationT, dataclasses._DataclassT]):
+    settings: SettingsT
+    application_type: type[ApplicationT] = dataclasses.field(init=False)
+    application_config: dataclasses._DataclassT = dataclasses.field(init=False)
+
+    sentry_instrument_type: type[Instrument[SentryInstrumentConfig]] = dataclasses.field(init=False)
+    opentelemetry_instrument_type: type[Instrument[OpentelemetryInstrumentConfig]] = dataclasses.field(init=False)
+
+    __sentry_instrument: Instrument[SentryInstrumentConfig] = dataclasses.field(init=False)
+    __opentelemetry_instrument: Instrument[OpentelemetryInstrumentConfig] = dataclasses.field(init=False)
+
+    def __post_init__(self) -> None:
+        settings_dump = self.settings.model_dump()
+        self.__sentry_instrument = self.sentry_instrument_type(SentryInstrumentConfig(**settings_dump))
+        self.__opentelemetry_instrument = self.opentelemetry_instrument_type(
+            OpentelemetryInstrumentConfig(**settings_dump),
+        )
+
+    def configure_application(self: SelfT, application_config: dataclasses._DataclassT) -> SelfT:
+        self.application_config = merge_dataclasses_configs(self.application_config, application_config)
+        return self
+
+    def configure_opentelemetry(
+        self: SelfT,
+        opentelemetry_config: OpentelemetryInstrumentConfig,
+    ) -> SelfT:
+        self.opentelemetry_instrument.configure_instrument(opentelemetry_config)
+        return self
+
+    def configure_sentry(
+        self: SelfT,
+        sentry_config: SentryInstrumentConfig,
+    ) -> SelfT:
+        self.sentry_instrument.configure_instrument(sentry_config)
+        return self
+
+    def configure_logging(self: SelfT) -> SelfT:
+        raise NotImplementedError
+
+    def bootstrap(self: SelfT) -> ApplicationT:
+        application_config_dict = dataclass_to_dict_no_defaults(self.application_config)
+        for instrument in self.__instruments:
+            application_config = merge_dict_configs(
+                application_config_dict,
+                instrument.bootstrap(),
+            )
+        return self.application_type(**application_config)
+
+    def teardown(self: SelfT) -> None:
+        for instrument in self.__instruments:
+            instrument.teardown()
+
+    @property
+    def __instruments(self) -> list[Instrument[typing.Any]]:
+        return [self.__sentry_instrument, self.__opentelemetry_instrument]

microbootstrap/bootstrappers/litestar.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+import typing
+
+import litestar
+import litestar.types
+import sentry_sdk
+from litestar import status_codes
+from litestar.config.app import AppConfig
+from litestar.contrib.opentelemetry.config import OpentelemetryInstrumentConfig
+from litestar.contrib.opentelemetry.middleware import OpenTelemetryInstrumentationMiddleware
+from litestar.exceptions.http_exceptions import HTTPException
+
+from microbootstrap.bootstrappers.base import ApplicationBootstrapper
+from microbootstrap.instruments import OpentelemetryInstrument, SentryInstrument
+from microbootstrap.settings.litestar import LitestarBootstrapSettings
+
+
+class LitestarSentryInstrument(SentryInstrument):
+    @staticmethod
+    async def sentry_exception_catcher_hook(
+        exception: Exception,
+        _request_scope: litestar.types.Scope,
+    ) -> None:
+        if (
+            not isinstance(exception, HTTPException)
+            or exception.status_code >= status_codes.HTTP_500_INTERNAL_SERVER_ERROR
+        ):
+            sentry_sdk.capture_exception(exception)
+
+    @property
+    def successful_bootstrap_result(self) -> dict[str, typing.Any]:
+        return {"after_exception": [self.sentry_exception_catcher_hook]}
+
+
+class LitetstarOpentelemetryInstrument(OpentelemetryInstrument):
+    @property
+    def successful_bootstrap_result(self) -> dict[str, typing.Any]:
+        return {
+            "middleware": OpenTelemetryInstrumentationMiddleware(
+                OpentelemetryInstrumentConfig(
+                    tracer_provider=self.tracer_provider,
+                    exclude=self.instrument_config.opentelemetry_exclude_urls,
+                ),
+            ),
+        }
+
+
+class LitestarBootstrapper(
+    ApplicationBootstrapper[LitestarBootstrapSettings, litestar.Litestar, AppConfig],
+):
+    sentry_instrument_type = LitestarSentryInstrument
+    opentelemetry_instrument_type = LitetstarOpentelemetryInstrument

microbootstrap/exceptions.py

@@ -0,0 +1,6 @@
+class MicroBootstrapBaseError(Exception):
+    """Base for all exceptions."""
+
+
+class ConfigMergeError(MicroBootstrapBaseError):
+    """Raises when it's impossible to merge configs due to type mismatch."""