microbootstrap 0.0.1__py3-none-any.whl

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,102 @@
+from __future__ import annotations
+import abc
+import typing
+
+import typing_extensions
+
+from microbootstrap.console_writer import ConsoleWriter
+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
+    console_writer: ConsoleWriter
+    __instrument_box: InstrumentBox
+
+    def __init__(self, settings: SettingsT) -> None:
+        self.settings = settings
+        self.console_writer = ConsoleWriter(writer_enabled=settings.service_debug)
+
+        if not hasattr(self, "__instrument_box"):
+            self.__instrument_box = InstrumentBox()
+        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
+
+    def configure_instruments(
+        self: typing_extensions.Self,
+        *instrument_configs: InstrumentConfigT,
+    ) -> typing_extensions.Self:
+        for instrument_config in instrument_configs:
+            self.configure_instrument(instrument_config)
+        return self
+
+    @classmethod
+    def use_instrument(
+        cls,
+    ) -> typing.Callable[
+        [type[Instrument[InstrumentConfigT]]],
+        type[Instrument[InstrumentConfigT]],
+    ]:
+        if not hasattr(cls, "__instrument_box"):
+            cls.__instrument_box = InstrumentBox()
+        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:
+            if instrument.is_ready():
+                instrument.bootstrap()
+
+                resulting_application_config = merge_dict_configs(
+                    resulting_application_config,
+                    instrument.bootstrap_before(),
+                )
+            instrument.write_status(self.console_writer)
+
+        application = self.application_type(
+            **merge_dict_configs(resulting_application_config, self.bootstrap_before()),
+        )
+
+        for instrument in self.__instrument_box.instruments:
+            if instrument.is_ready():
+                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,86 @@
+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],
+            "on_startup": [self.console_writer.print_bootstrap_table],
+        }
+
+
+@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/console_writer.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+import dataclasses
+import typing
+
+from rich.console import Console
+from rich.rule import Rule
+from rich.table import Table
+
+
+@dataclasses.dataclass
+class ConsoleWriter:
+    writer_enabled: bool = True
+    rich_console: Console = dataclasses.field(init=False, default_factory=Console)
+    rich_table: Table = dataclasses.field(init=False)
+
+    def __post_init__(self) -> None:
+        self.rich_table = Table(show_header=False, header_style="cyan")
+        self.rich_table.add_column("Item", style="cyan")
+        self.rich_table.add_column("Status")
+        self.rich_table.add_column("Reason", style="yellow")
+
+    def write_instrument_status(
+        self,
+        instrument_name: str,
+        is_enabled: bool,
+        disable_reason: str | None = None,
+    ) -> None:
+        is_enabled_value: typing.Final = "[green]Enabled[/green]" if is_enabled else "[red]Disabled[/red]"
+        self.rich_table.add_row(rf"{instrument_name}", is_enabled_value, disable_reason or "")
+
+    def print_bootstrap_table(self) -> None:
+        if self.writer_enabled:
+            self.rich_console.print(Rule("[yellow]Bootstrapping application[/yellow]", align="left"))
+            self.rich_console.print(self.rich_table)

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."""

microbootstrap/granian_server.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+import logging
+import typing
+
+import granian
+from granian.constants import Interfaces, Loops
+from granian.log import LogLevels
+
+
+if typing.TYPE_CHECKING:
+    from microbootstrap.settings import BaseBootstrapSettings
+
+
+GRANIAN_LOG_LEVELS_MAP = {
+    logging.CRITICAL: LogLevels.critical,
+    logging.ERROR: LogLevels.error,
+    logging.WARNING: LogLevels.warning,
+    logging.WARNING: LogLevels.warn,
+    logging.INFO: LogLevels.info,
+    logging.DEBUG: LogLevels.debug,
+}
+
+
+# TODO: create bootstrappers for application servers. granian/uvicorn  # noqa: TD002
+def create_granian_server(
+    target: str,
+    settings: BaseBootstrapSettings,
+    **granian_options: typing.Any,  # noqa: ANN401
+) -> granian.Granian:
+    return granian.Granian(
+        target=target,
+        address=settings.server_host,
+        port=settings.server_port,
+        interface=Interfaces.ASGI,
+        loop=Loops.uvloop,
+        workers=settings.server_workers_count,
+        log_level=GRANIAN_LOG_LEVELS_MAP[settings.logging_log_level],
+        reload=settings.server_reload,
+        **granian_options,
+    )

microbootstrap/helpers.py

@@ -0,0 +1,96 @@
+import dataclasses
+import re
+import typing
+from dataclasses import _MISSING_TYPE
+
+from microbootstrap import exceptions
+
+
+if typing.TYPE_CHECKING:
+    from dataclasses import _DataclassT
+
+    from pydantic import BaseModel
+
+
+PydanticConfigT = typing.TypeVar("PydanticConfigT", bound="BaseModel")
+VALID_PATH_PATTERN: typing.Final = r"^(/[a-zA-Z0-9_-]+)+/?$"
+
+
+def dataclass_to_dict_no_defaults(dataclass_to_convert: "_DataclassT") -> dict[str, typing.Any]:
+    conversion_result: typing.Final = {}
+    for dataclass_field in dataclasses.fields(dataclass_to_convert):
+        value = getattr(dataclass_to_convert, dataclass_field.name)
+        if isinstance(dataclass_field.default, _MISSING_TYPE):
+            conversion_result[dataclass_field.name] = value
+            continue
+        if dataclass_field.default != value and isinstance(dataclass_field.default_factory, _MISSING_TYPE):
+            conversion_result[dataclass_field.name] = value
+            continue
+        if value != dataclass_field.default and value != dataclass_field.default_factory():  # type: ignore[misc]
+            conversion_result[dataclass_field.name] = value
+
+    return conversion_result
+
+
+def merge_pydantic_configs(
+    config_to_merge: PydanticConfigT,
+    config_with_changes: PydanticConfigT,
+) -> PydanticConfigT:
+    config_class: typing.Final = config_to_merge.__class__
+    resulting_dict_config: typing.Final = merge_dict_configs(
+        config_to_merge.model_dump(exclude_defaults=True, exclude_unset=True),
+        config_with_changes.model_dump(exclude_defaults=True, exclude_unset=True),
+    )
+    return config_class(**resulting_dict_config)
+
+
+def merge_dataclasses_configs(
+    config_to_merge: "_DataclassT",
+    config_with_changes: "_DataclassT",
+) -> "_DataclassT":
+    config_class: typing.Final = config_to_merge.__class__
+    resulting_dict_config: typing.Final = merge_dict_configs(
+        dataclass_to_dict_no_defaults(config_to_merge),
+        dataclass_to_dict_no_defaults(config_with_changes),
+    )
+    return config_class(**resulting_dict_config)
+
+
+def merge_dict_configs(
+    config_dict: dict[str, typing.Any],
+    changes_dict: dict[str, typing.Any],
+) -> dict[str, typing.Any]:
+    for change_key, change_value in changes_dict.items():
+        config_value = config_dict.get(change_key)
+
+        if isinstance(config_value, set):
+            if not isinstance(change_value, set):
+                raise exceptions.ConfigMergeError(f"Can't merge {config_value} and {change_value}")
+            config_dict[change_key] = {*config_value, *change_value}
+            continue
+
+        if isinstance(config_value, tuple):
+            if not isinstance(change_value, tuple):
+                raise exceptions.ConfigMergeError(f"Can't merge {config_value} and {change_value}")
+            config_dict[change_key] = (*config_value, *change_value)
+            continue
+
+        if isinstance(config_value, list):
+            if not isinstance(change_value, list):
+                raise exceptions.ConfigMergeError(f"Can't merge {config_value} and {change_value}")
+            config_dict[change_key] = [*config_value, *change_value]
+            continue
+
+        if isinstance(config_value, dict):
+            if not isinstance(change_value, dict):
+                raise exceptions.ConfigMergeError(f"Can't merge {config_value} and {change_value}")
+            config_dict[change_key] = {**config_value, **change_value}
+            continue
+
+        config_dict[change_key] = change_value
+
+    return config_dict
+
+
+def is_valid_path(maybe_path: str) -> bool:
+    return bool(re.fullmatch(VALID_PATH_PATTERN, maybe_path))

microbootstrap/instruments/__init__.py

@@ -0,0 +1,7 @@
+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
+
+
+__all__ = ("SentryConfig", "OpentelemetryConfig", "PrometheusConfig", "LoggingConfig")

microbootstrap/instruments/base.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+import abc
+import dataclasses
+import typing
+
+import pydantic
+
+from microbootstrap.helpers import merge_pydantic_configs
+
+
+if typing.TYPE_CHECKING:
+    from microbootstrap.console_writer import ConsoleWriter
+
+
+InstrumentConfigT = typing.TypeVar("InstrumentConfigT", bound="BaseInstrumentConfig")
+ApplicationT = typing.TypeVar("ApplicationT")
+
+
+class BaseInstrumentConfig(pydantic.BaseModel):
+    model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
+
+
+@dataclasses.dataclass
+class Instrument(abc.ABC, typing.Generic[InstrumentConfigT]):
+    instrument_config: InstrumentConfigT
+
+    def configure_instrument(
+        self,
+        incoming_config: InstrumentConfigT,
+    ) -> None:
+        self.instrument_config = merge_pydantic_configs(self.instrument_config, incoming_config)
+
+    @abc.abstractmethod
+    def write_status(self, console_writer: ConsoleWriter) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def is_ready(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def bootstrap(self) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def teardown(self) -> None:
+        raise NotImplementedError
+
+    @classmethod
+    @abc.abstractmethod
+    def get_config_type(cls) -> type[InstrumentConfigT]:
+        raise NotImplementedError
+
+    def bootstrap_before(self) -> dict[str, typing.Any]:
+        """Add some framework-related parameters to final bootstrap result before application creation."""
+        return {}
+
+    def bootstrap_after(self, application: ApplicationT) -> ApplicationT:
+        """Add some framework-related parameters to final bootstrap result after application creation."""
+        return application

microbootstrap/instruments/instrument_box.py

@@ -0,0 +1,51 @@
+import typing
+
+import typing_extensions
+
+from microbootstrap import exceptions
+from microbootstrap.instruments.base import Instrument, InstrumentConfigT
+from microbootstrap.settings import SettingsT
+
+
+class InstrumentBox:
+    __instruments__: typing.ClassVar[list[type[Instrument[typing.Any]]]] = []
+    __initialized_instruments__: list[Instrument[typing.Any]]
+
+    def initialize(self, settings: SettingsT) -> None:
+        settings_dump = settings.model_dump()
+        self.__initialized_instruments__ = [
+            instrument_type(instrument_type.get_config_type()(**settings_dump))
+            for instrument_type in self.__instruments__
+        ]
+
+    def configure_instrument(
+        self: typing_extensions.Self,
+        instrument_config: InstrumentConfigT,
+    ) -> None:
+        for instrument in self.__initialized_instruments__:
+            if isinstance(instrument_config, instrument.get_config_type()):
+                instrument.configure_instrument(instrument_config)
+                return
+
+        raise exceptions.MissingInstrumentError(
+            f"Instrument for config {instrument_config.__class__.__name__} is not supported yet.",
+        )
+
+    @classmethod
+    def extend_instruments(
+        cls,
+        instrument_class: type[Instrument[InstrumentConfigT]],
+    ) -> type[Instrument[InstrumentConfigT]]:
+        """Extend list of instruments, excluding one whose config is already in use."""
+        cls.__instruments__ = list(
+            filter(
+                lambda instrument: instrument.get_config_type() is not instrument_class.get_config_type(),
+                cls.__instruments__,
+            ),
+        )
+        cls.__instruments__.append(instrument_class)
+        return instrument_class
+
+    @property
+    def instruments(self) -> list[Instrument[typing.Any]]:
+        return self.__initialized_instruments__

microbootstrap/instruments/logging_instrument.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+import logging
+import logging.handlers
+import time
+import typing
+import urllib.parse
+
+import pydantic
+import structlog
+from opentelemetry import trace
+
+from microbootstrap.instruments.base import BaseInstrumentConfig, Instrument
+
+
+if typing.TYPE_CHECKING:
+    import fastapi
+    import litestar
+    from structlog.typing import EventDict, WrappedLogger
+
+    from microbootstrap.console_writer import ConsoleWriter
+
+
+ScopeType = typing.MutableMapping[str, typing.Any]
+
+access_logger: typing.Final = structlog.get_logger("api.access")
+
+
+def make_path_with_query_string(scope: ScopeType) -> str:
+    path_with_query_string: typing.Final = urllib.parse.quote(scope["path"])
+    if scope["query_string"]:
+        return f'{path_with_query_string}?{scope["query_string"].decode("ascii")}'
+    return path_with_query_string
+
+
+def fill_log_message(
+    log_level: str,
+    request: litestar.Request | fastapi.Request,
+    status_code: int,
+    start_time: int,
+) -> None:
+    process_time: typing.Final = time.perf_counter_ns() - start_time
+    url_with_query: typing.Final = make_path_with_query_string(typing.cast(ScopeType, request.scope))
+    client_host: typing.Final = request.client.host if request.client is not None else None
+    client_port: typing.Final = request.client.port if request.client is not None else None
+    http_method: typing.Final = request.method
+    http_version: typing.Final = request.scope["http_version"]
+    log_on_correct_level: typing.Final = getattr(access_logger, log_level)
+    log_on_correct_level(
+        http={
+            "url": url_with_query,
+            "status_code": status_code,
+            "method": http_method,
+            "version": http_version,
+        },
+        network={"client": {"ip": client_host, "port": client_port}},
+        duration=process_time,
+    )
+
+
+def tracer_injection(_: WrappedLogger, __: str, event_dict: EventDict) -> EventDict:
+    event_dict["tracing"] = {}
+    current_span: typing.Final[trace.Span] = trace.get_current_span()
+    if current_span == trace.INVALID_SPAN:
+        return event_dict
+
+    span_context: typing.Final[trace.SpanContext] = current_span.get_span_context()
+    if span_context == trace.INVALID_SPAN_CONTEXT:
+        return event_dict
+
+    event_dict["tracing"]["trace_id"] = format(span_context.span_id, "016x")
+    event_dict["tracing"]["span_id"] = format(span_context.trace_id, "032x")
+
+    return event_dict
+
+
+DEFAULT_STRUCTLOG_PROCESSORS: typing.Final[list[typing.Any]] = [
+    structlog.stdlib.filter_by_level,
+    structlog.stdlib.add_log_level,
+    structlog.stdlib.add_logger_name,
+    tracer_injection,
+    structlog.stdlib.PositionalArgumentsFormatter(),
+    structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S"),
+    structlog.processors.StackInfoRenderer(),
+    structlog.processors.format_exc_info,
+    structlog.processors.UnicodeDecoder(),
+]
+DEFAULT_STRUCTLOG_FORMATTER_PROCESSOR: typing.Final = structlog.processors.JSONRenderer()
+
+
+class MemoryLoggerFactory(structlog.stdlib.LoggerFactory):
+    def __init__(
+        self,
+        *args: typing.Any,  # noqa: ANN401
+        logging_buffer_capacity: int,
+        logging_flush_level: int,
+        logging_log_level: int,
+        log_stream: typing.Any = None,  # noqa: ANN401
+        **kwargs: typing.Any,  # noqa: ANN401
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.logging_buffer_capacity = logging_buffer_capacity
+        self.logging_flush_level = logging_flush_level
+        self.logging_log_level = logging_log_level
+        self.log_stream = log_stream
+
+    def __call__(self, *args: typing.Any) -> logging.Logger:  # noqa: ANN401
+        logger: typing.Final = super().__call__(*args)
+        stream_handler: typing.Final = logging.StreamHandler(stream=self.log_stream)
+        handler: typing.Final = logging.handlers.MemoryHandler(
+            capacity=self.logging_buffer_capacity,
+            flushLevel=self.logging_flush_level,
+            target=stream_handler,
+        )
+        logger.addHandler(handler)
+        logger.setLevel(self.logging_log_level)
+        logger.propagate = False
+        return logger
+
+
+class LoggingConfig(BaseInstrumentConfig):
+    service_debug: bool = True
+
+    logging_log_level: int = pydantic.Field(default=logging.INFO)
+    logging_flush_level: int = pydantic.Field(default=logging.ERROR)
+    logging_buffer_capacity: int = pydantic.Field(default=10)
+    logging_extra_processors: list[typing.Any] = pydantic.Field(default_factory=list)
+    logging_unset_handlers: list[str] = pydantic.Field(
+        default_factory=lambda: ["uvicorn", "uvicorn.access"],
+    )
+    logging_exclude_endpoints: list[str] = pydantic.Field(default_factory=lambda: ["/health"])
+
+
+class LoggingInstrument(Instrument[LoggingConfig]):
+    def write_status(self, console_writer: ConsoleWriter) -> None:
+        if self.is_ready():
+            console_writer.write_instrument_status("Logging", is_enabled=True)
+        else:
+            console_writer.write_instrument_status(
+                "Logging",
+                is_enabled=False,
+                disable_reason="Works only in non-debug mode",
+            )
+
+    def is_ready(self) -> bool:
+        return not self.instrument_config.service_debug
+
+    def teardown(self) -> None:
+        structlog.reset_defaults()
+
+    def bootstrap(self) -> None:
+        for unset_handlers_logger in self.instrument_config.logging_unset_handlers:
+            logging.getLogger(unset_handlers_logger).handlers = []
+
+        structlog.configure(
+            processors=[
+                *DEFAULT_STRUCTLOG_PROCESSORS,
+                *self.instrument_config.logging_extra_processors,
+                DEFAULT_STRUCTLOG_FORMATTER_PROCESSOR,
+            ],
+            context_class=dict,
+            logger_factory=MemoryLoggerFactory(
+                logging_buffer_capacity=self.instrument_config.logging_buffer_capacity,
+                logging_flush_level=self.instrument_config.logging_flush_level,
+                logging_log_level=self.instrument_config.logging_log_level,
+            ),
+            wrapper_class=structlog.stdlib.BoundLogger,
+            cache_logger_on_first_use=True,
+        )
+
+    @classmethod
+    def get_config_type(cls) -> type[LoggingConfig]:
+        return LoggingConfig