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

README.md

@@ -1,6 +1,51 @@
 # microbootstrap
+This package helps you create application with all necessary instruments already set up
 
-<img src="./logo.svg" width="300" />
+- `sentry`
+- `prometheus`
+- `opentelemetry`
+- `logging`
 
+```python
+# settings.py
+from microbootstrap import LitestarSettings
 
-To be done...
+
+class YourSettings(LitestarSettings):
+    # Your settings stored here
+
+
+settings = YourSettings()
+
+
+# application.py
+import litestar
+from microbootstrap.bootstrappers.litestar import LitestarBootstrapper
+
+from your_application.settings import settings
+
+# Litestar application with all instruments ready for use!
+application: litestar.Litestar = LitestarBootstrapper(settings).bootstrap()
+```
+
+Interested? Let's jump right into it ⚡
+
+## Installation
+
+You can install `microbootstrap` with extra for framework you need.
+
+poetry:
+
+```bash
+$ poetry add microbootstrap -E litestar
+# or
+$ poetry add microbootstrap -E fastapi
+```
+
+pip:
+
+```bash
+$ pip install microbootsrap[litestar]
+# or
+$ pip install microbootsrap[fastapi]
+```

microbootstrap/__init__.py

@@ -0,0 +1,15 @@
+from microbootstrap.instruments.logging_instrument import LoggingConfig
+from microbootstrap.instruments.opentelemetry_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,80 @@
+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:
+    from _typeshed import DataclassInstance
+
+    from microbootstrap.instruments.base import Instrument, InstrumentConfigT
+
+
+ApplicationT = typing.TypeVar("ApplicationT")
+DataclassT = typing.TypeVar("DataclassT", bound="DataclassInstance")
+
+
+class ApplicationBootstrapper(abc.ABC, typing.Generic[SettingsT, ApplicationT, DataclassT]):
+    application_type: type[ApplicationT]
+    application_config: DataclassT
+    __instrument_box: InstrumentBox = InstrumentBox()
+
+    def __init__(self, settings: SettingsT) -> None:
+        self.settings = settings
+        self.__instrument_box.initialize(self.settings)
+
+    def configure_application(
+        self: typing_extensions.Self,
+        application_config: 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.opentelemetry_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 {"debug": self.settings.service_debug, "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_endpoints)]}
+
+
+@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 supported yet."""