Full refactoring.

.github/workflows/workflow.yml

@@ -14,4 +14,5 @@ on:
 
 jobs:
   ci:
-    uses: community-of-python/community-workflow/.github/workflows/preset.yml@main
+    uses: community-of-python/community-workflow/.github/workflows/preset.yml@main
+    secrets: inherit

microbootstrap/__init__.py

@@ -0,0 +1,18 @@
+"""Contains everything that's needed for bootstrapping."""
+
+from microbootstrap.bootstrappers.litestar import LitestarBootstrapper
+from microbootstrap.instruments.logging_instrument import LoggingConfig
+from microbootstrap.instruments.opentelemery_instrument import OpentelemetryConfig
+from microbootstrap.instruments.prometheus_instrument import PrometheusConfig
+from microbootstrap.instruments.sentry_instrument import SentryConfig
+from microbootstrap.settings import LitestarSettings
+
+
+__all__ = (
+    "SentryConfig",
+    "OpentelemetryConfig",
+    "PrometheusConfig",
+    "LoggingConfig",
+    "LitestarBootstrapper",
+    "LitestarSettings",
+)

microbootstrap/bootstrappers/base.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+import abc
+import typing
+
+import typing_extensions
+
+from microbootstrap.helpers import dataclass_to_dict_no_defaults, merge_dataclasses_configs, merge_dict_configs
+from microbootstrap.instruments.instrument_box import InstrumentBox
+from microbootstrap.settings import SettingsT
+
+
+if typing.TYPE_CHECKING:
+    import dataclasses
+
+    from _typeshed import DataclassInstance
+
+    from microbootstrap.instruments.base import Instrument, InstrumentConfigT
+
+
+ApplicationT = typing.TypeVar("ApplicationT")
+DataclassT_co = typing.TypeVar("DataclassT_co", bound="DataclassInstance", covariant=True)
+
+
+class ApplicationBootstrapper(abc.ABC, typing.Generic[SettingsT, ApplicationT, DataclassT_co]):
+    application_type: type[ApplicationT]
+    application_config: dataclasses._DataclassT
+    __instrument_box: InstrumentBox = InstrumentBox()
+
+    def __init__(self, settings: SettingsT) -> None:
+        self.settings = settings
+
+    def __post_init__(self) -> None:
+        self.__instrument_box.initialize(self.settings)
+
+    def configure_application(
+        self: typing_extensions.Self,
+        application_config: dataclasses._DataclassT,
+    ) -> typing_extensions.Self:
+        self.application_config = merge_dataclasses_configs(self.application_config, application_config)
+        return self
+
+    def configure_instrument(
+        self: typing_extensions.Self,
+        instrument_config: InstrumentConfigT,
+    ) -> typing_extensions.Self:
+        self.__instrument_box.configure_instrument(instrument_config)
+        return self
+
+    @classmethod
+    def use_instrument(
+        cls,
+    ) -> typing.Callable[
+        [type[Instrument[InstrumentConfigT]]],
+        type[Instrument[InstrumentConfigT]],
+    ]:
+        return cls.__instrument_box.extend_instruments
+
+    def bootstrap(self: typing_extensions.Self) -> ApplicationT:
+        resulting_application_config = dataclass_to_dict_no_defaults(self.application_config)
+        for instrument in self.__instrument_box.instruments:
+            resulting_application_config = merge_dict_configs(
+                resulting_application_config,
+                instrument.bootstrap(),
+            )
+
+        application = self.application_type(
+            **merge_dict_configs(resulting_application_config, self.bootstrap_before()),
+        )
+
+        for instrument in self.__instrument_box.instruments:
+            application = instrument.bootstrap_after(application)
+        return self.bootstrap_after(application)
+
+    def bootstrap_before(self: typing_extensions.Self) -> dict[str, typing.Any]:
+        """Add some framework-related parameters to final bootstrap result before application creation."""
+        return {}
+
+    def bootstrap_after(self: typing_extensions.Self, application: ApplicationT) -> ApplicationT:
+        """Add some framework-related parameters to final bootstrap result after application creation."""
+        return application
+
+    def teardown(self: typing_extensions.Self) -> None:
+        for instrument in self.__instrument_box.instruments:
+            instrument.teardown()

microbootstrap/bootstrappers/litestar.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+import typing
+
+import litestar
+import litestar.types
+import sentry_sdk
+import typing_extensions
+from litestar import status_codes
+from litestar.config.app import AppConfig as LitestarConfig
+from litestar.contrib.opentelemetry.config import OpenTelemetryConfig as LitestarOpentelemetryConfig
+from litestar.contrib.prometheus import PrometheusConfig as LitestarPrometheusConfig
+from litestar.contrib.prometheus import PrometheusController
+from litestar.exceptions.http_exceptions import HTTPException
+
+from microbootstrap.bootstrappers.base import ApplicationBootstrapper
+from microbootstrap.instruments.logging_instrument import LoggingInstrument
+from microbootstrap.instruments.opentelemery_instrument import OpentelemetryInstrument
+from microbootstrap.instruments.prometheus_instrument import PrometheusInstrument
+from microbootstrap.instruments.sentry_instrument import SentryInstrument
+from microbootstrap.middlewares.litestar import build_litestar_logging_middleware
+from microbootstrap.settings import LitestarSettings
+
+
+class LitestarBootstrapper(
+    ApplicationBootstrapper[LitestarSettings, litestar.Litestar, LitestarConfig],
+):
+    application_config = LitestarConfig()
+    application_type = litestar.Litestar
+
+    def bootstrap_before(self: typing_extensions.Self) -> dict[str, typing.Any]:
+        return {"on_shutdown": [self.teardown]}
+
+
+@LitestarBootstrapper.use_instrument()
+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)
+
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {"after_exception": [self.sentry_exception_catcher_hook]}
+
+
+@LitestarBootstrapper.use_instrument()
+class LitetstarOpentelemetryInstrument(OpentelemetryInstrument):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {
+            "middleware": [
+                LitestarOpentelemetryConfig(
+                    tracer_provider=self.tracer_provider,
+                    exclude=self.instrument_config.opentelemetry_exclude_urls,
+                ).middleware,
+            ],
+        }
+
+
+@LitestarBootstrapper.use_instrument()
+class LitestarLoggingInstrument(LoggingInstrument):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        return {"middleware": build_litestar_logging_middleware(self.instrument_config.logging_exclude_endpoings)}
+
+
+@LitestarBootstrapper.use_instrument()
+class LitestarPrometheusInstrument(PrometheusInstrument):
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        class LitestarPrometheusController(PrometheusController):
+            path = self.instrument_config.prometheus_metrics_path
+            openmetrics_format = True
+
+        litestar_prometheus_config: typing.Final = LitestarPrometheusConfig(
+            app_name=self.instrument_config.service_name,
+            **self.instrument_config.prometheus_additional_params,
+        )
+
+        return {"route_handlers": [LitestarPrometheusController], "middleware": [litestar_prometheus_config.middleware]}

microbootstrap/exceptions.py

@@ -0,0 +1,10 @@
+class MicroBootstrapBaseError(Exception):
+    """Base for all exceptions."""
+
+
+class ConfigMergeError(MicroBootstrapBaseError):
+    """Raises when it's impossible to merge configs due to type mismatch."""
+
+
+class MissingInstrumentError(MicroBootstrapBaseError):
+    """Raises when attempting to configure instrument, that is not suported yet."""