lite-bootstrap 0.2.0__tar.gz → 0.4.0__tar.gz

{lite_bootstrap-0.2.0 → lite_bootstrap-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lite-bootstrap
-Version: 0.2.0
+Version: 0.4.0
 Summary: Lite package for bootstrapping new microservices
 Project-URL: repository, https://github.com/modern-python/lite-bootstrap
 Author-email: Artur Shiriev <me@shiriev.ru>
@@ -15,8 +15,19 @@ Classifier: Typing :: Typed
 Requires-Python: <4,>=3.10
 Provides-Extra: fastapi
 Requires-Dist: fastapi; extra == 'fastapi'
+Provides-Extra: fastapi-all
+Requires-Dist: fastapi; extra == 'fastapi-all'
+Requires-Dist: opentelemetry-api; extra == 'fastapi-all'
+Requires-Dist: opentelemetry-exporter-otlp; extra == 'fastapi-all'
+Requires-Dist: opentelemetry-instrumentation; extra == 'fastapi-all'
+Requires-Dist: opentelemetry-instrumentation-fastapi; extra == 'fastapi-all'
+Requires-Dist: opentelemetry-sdk; extra == 'fastapi-all'
+Requires-Dist: sentry-sdk; extra == 'fastapi-all'
+Requires-Dist: structlog; extra == 'fastapi-all'
 Provides-Extra: fastapi-otl
 Requires-Dist: opentelemetry-instrumentation-fastapi; extra == 'fastapi-otl'
+Provides-Extra: logging
+Requires-Dist: structlog; extra == 'logging'
 Provides-Extra: otl
 Requires-Dist: opentelemetry-api; extra == 'otl'
 Requires-Dist: opentelemetry-exporter-otlp; extra == 'otl'

lite_bootstrap-0.4.0/lite_bootstrap/bootstraps/base.py

@@ -0,0 +1,22 @@
+import abc
+import typing
+
+from lite_bootstrap.instruments.base import BaseInstrument
+from lite_bootstrap.service_config import ServiceConfig
+from lite_bootstrap.types import ApplicationT
+
+
+class BaseBootstrap(abc.ABC, typing.Generic[ApplicationT]):
+    application: ApplicationT
+    instruments: typing.Sequence[BaseInstrument]
+    service_config: ServiceConfig
+
+    def bootstrap(self) -> None:
+        for one_instrument in self.instruments:
+            if one_instrument.is_ready(self.service_config):
+                one_instrument.bootstrap(self.service_config, self.application)
+
+    def teardown(self) -> None:
+        for one_instrument in self.instruments:
+            if one_instrument.is_ready(self.service_config):
+                one_instrument.teardown(self.application)

lite_bootstrap-0.4.0/lite_bootstrap/bootstraps/fastapi_bootstrap/__init__.py

@@ -0,0 +1,33 @@
+import dataclasses
+import typing
+
+import fastapi
+
+from lite_bootstrap.bootstraps.base import BaseBootstrap
+from lite_bootstrap.bootstraps.fastapi_bootstrap.healthchecks_instrument import FastAPIHealthChecksInstrument
+from lite_bootstrap.bootstraps.fastapi_bootstrap.logging_instrument import FastAPILoggingInstrument
+from lite_bootstrap.bootstraps.fastapi_bootstrap.opentelemetry_instrument import FastAPIOpenTelemetryInstrument
+from lite_bootstrap.bootstraps.fastapi_bootstrap.sentry_instrument import FastAPISentryInstrument
+
+
+__all__ = [
+    "FastAPIBootstrap",
+    "FastAPIHealthChecksInstrument",
+    "FastAPILoggingInstrument",
+    "FastAPIOpenTelemetryInstrument",
+    "FastAPISentryInstrument",
+]
+
+from lite_bootstrap.service_config import ServiceConfig
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class FastAPIBootstrap(BaseBootstrap[fastapi.FastAPI]):
+    application: fastapi.FastAPI
+    instruments: typing.Sequence[
+        FastAPIOpenTelemetryInstrument
+        | FastAPISentryInstrument
+        | FastAPIHealthChecksInstrument
+        | FastAPILoggingInstrument
+    ]
+    service_config: ServiceConfig

lite_bootstrap-0.4.0/lite_bootstrap/bootstraps/fastapi_bootstrap/healthchecks_instrument.py

@@ -0,0 +1,30 @@
+import dataclasses
+import typing
+
+import fastapi
+
+from lite_bootstrap.instruments.healthchecks_instrument import HealthChecksInstrument, HealthCheckTypedDict
+from lite_bootstrap.service_config import ServiceConfig
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class FastAPIHealthChecksInstrument(HealthChecksInstrument):
+    enabled: bool = True
+    path: str = "/health/"
+    include_in_schema: bool = False
+
+    def build_fastapi_health_check_router(self, service_config: ServiceConfig) -> fastapi.APIRouter:
+        fastapi_router: typing.Final = fastapi.APIRouter(
+            tags=["probes"],
+            include_in_schema=self.include_in_schema,
+        )
+
+        @fastapi_router.get(self.path)
+        async def health_check_handler() -> HealthCheckTypedDict:
+            return self.render_health_check_data(service_config)
+
+        return fastapi_router
+
+    def bootstrap(self, service_config: ServiceConfig, application: fastapi.FastAPI | None = None) -> None:
+        if application:
+            application.include_router(self.build_fastapi_health_check_router(service_config))

lite_bootstrap-0.4.0/lite_bootstrap/bootstraps/fastapi_bootstrap/logging_instrument.py

@@ -0,0 +1,7 @@
+import dataclasses
+
+from lite_bootstrap.instruments.logging_instrument import LoggingInstrument
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class FastAPILoggingInstrument(LoggingInstrument): ...

lite_bootstrap-0.4.0/lite_bootstrap/bootstraps/fastapi_bootstrap/opentelemetry_instrument.py

@@ -0,0 +1,30 @@
+import contextlib
+import dataclasses
+
+import fastapi
+from opentelemetry.trace import get_tracer_provider
+
+from lite_bootstrap.instruments.opentelemetry_instrument import OpenTelemetryInstrument
+from lite_bootstrap.service_config import ServiceConfig
+
+
+with contextlib.suppress(ImportError):
+    from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class FastAPIOpenTelemetryInstrument(OpenTelemetryInstrument):
+    excluded_urls: list[str] = dataclasses.field(default_factory=list)
+
+    def bootstrap(self, service_config: ServiceConfig, application: fastapi.FastAPI | None = None) -> None:
+        super().bootstrap(service_config, application)
+        FastAPIInstrumentor.instrument_app(
+            app=application,
+            tracer_provider=get_tracer_provider(),
+            excluded_urls=",".join(self.excluded_urls),
+        )
+
+    def teardown(self, application: fastapi.FastAPI | None = None) -> None:
+        if application:
+            FastAPIInstrumentor.uninstrument_app(application)
+        super().teardown()

lite_bootstrap-0.4.0/lite_bootstrap/bootstraps/fastapi_bootstrap/sentry_instrument.py

@@ -0,0 +1,7 @@
+import dataclasses
+
+from lite_bootstrap.instruments.sentry_instrument import SentryInstrument
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class FastAPISentryInstrument(SentryInstrument): ...

lite_bootstrap-0.4.0/lite_bootstrap/instruments/base.py

@@ -0,0 +1,13 @@
+import abc
+
+from lite_bootstrap.service_config import ServiceConfig
+from lite_bootstrap.types import ApplicationT
+
+
+class BaseInstrument(abc.ABC):
+    def bootstrap(self, service_config: ServiceConfig, application: ApplicationT | None = None) -> None: ...  # noqa: B027
+
+    def teardown(self, application: ApplicationT | None = None) -> None: ...  # noqa: B027
+
+    @abc.abstractmethod
+    def is_ready(self, service_config: ServiceConfig) -> bool: ...

lite_bootstrap-0.4.0/lite_bootstrap/instruments/healthchecks_instrument.py

@@ -0,0 +1,30 @@
+import dataclasses
+
+import typing_extensions
+
+from lite_bootstrap.instruments.base import BaseInstrument
+from lite_bootstrap.service_config import ServiceConfig
+
+
+class HealthCheckTypedDict(typing_extensions.TypedDict, total=False):
+    service_version: str | None
+    service_name: str | None
+    health_status: bool
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class HealthChecksInstrument(BaseInstrument):
+    enabled: bool = True
+    path: str = "/health/"
+    include_in_schema: bool = False
+
+    def is_ready(self, _: ServiceConfig) -> bool:
+        return self.enabled
+
+    @staticmethod
+    def render_health_check_data(service_config: ServiceConfig) -> HealthCheckTypedDict:
+        return {
+            "service_version": service_config.service_version,
+            "service_name": service_config.service_name,
+            "health_status": True,
+        }

lite_bootstrap-0.4.0/lite_bootstrap/instruments/logging_instrument.py

@@ -0,0 +1,133 @@
+import contextlib
+import dataclasses
+import logging
+import logging.handlers
+import typing
+
+from lite_bootstrap.instruments.base import BaseInstrument
+from lite_bootstrap.service_config import ServiceConfig
+from lite_bootstrap.types import ApplicationT
+
+
+if typing.TYPE_CHECKING:
+    from structlog.typing import EventDict, WrappedLogger
+
+
+with contextlib.suppress(ImportError):
+    import structlog
+
+
+ScopeType = typing.MutableMapping[str, typing.Any]
+
+
+class AddressProtocol(typing.Protocol):
+    host: str
+    port: int
+
+
+class RequestProtocol(typing.Protocol):
+    client: AddressProtocol
+    scope: ScopeType
+    method: str
+
+
+def tracer_injection(_: "WrappedLogger", __: str, event_dict: "EventDict") -> "EventDict":
+    try:
+        from opentelemetry import trace
+    except ImportError:  # pragma: no cover
+        return event_dict
+
+    event_dict["tracing"] = {}
+    current_span = trace.get_current_span()
+    if current_span == trace.INVALID_SPAN:
+        return event_dict
+
+    span_context = current_span.get_span_context()
+    if span_context == trace.INVALID_SPAN_CONTEXT:  # pragma: no cover
+        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
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class LoggingInstrument(BaseInstrument):
+    logging_log_level: int = logging.INFO
+    logging_flush_level: int = logging.ERROR
+    logging_buffer_capacity: int = 10
+    logging_extra_processors: list[typing.Any] = dataclasses.field(default_factory=list)
+    logging_unset_handlers: list[str] = dataclasses.field(
+        default_factory=list,
+    )
+
+    def is_ready(self, service_config: ServiceConfig) -> bool:
+        return not service_config.service_debug
+
+    def bootstrap(self, _: ServiceConfig, __: ApplicationT | None = None) -> None:
+        for unset_handlers_logger in self.logging_unset_handlers:
+            logging.getLogger(unset_handlers_logger).handlers = []
+
+        structlog.configure(
+            processors=[
+                *DEFAULT_STRUCTLOG_PROCESSORS,
+                *self.logging_extra_processors,
+                DEFAULT_STRUCTLOG_FORMATTER_PROCESSOR,
+            ],
+            context_class=dict,
+            logger_factory=MemoryLoggerFactory(
+                logging_buffer_capacity=self.logging_buffer_capacity,
+                logging_flush_level=self.logging_flush_level,
+                logging_log_level=self.logging_log_level,
+            ),
+            wrapper_class=structlog.stdlib.BoundLogger,
+            cache_logger_on_first_use=True,
+        )
+
+    def teardown(self, _: ApplicationT | None = None) -> None:
+        structlog.reset_defaults()

{lite_bootstrap-0.2.0 → lite_bootstrap-0.4.0}/lite_bootstrap/instruments/opentelemetry_instrument.py

@@ -1,14 +1,20 @@
+import contextlib
 import dataclasses
 import typing
 
-import pydantic
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
-from opentelemetry.instrumentation.instrumentor import BaseInstrumentor  # type: ignore[attr-defined]
-from opentelemetry.sdk import resources
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.trace import set_tracer_provider
 
 from lite_bootstrap.instruments.base import BaseInstrument
+from lite_bootstrap.service_config import ServiceConfig
+from lite_bootstrap.types import ApplicationT
+
+
+with contextlib.suppress(ImportError):
+    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+    from opentelemetry.instrumentation.instrumentor import BaseInstrumentor  # type: ignore[attr-defined]
+    from opentelemetry.sdk import resources
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanExporter
 
 
 @dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
@@ -17,48 +23,34 @@ class InstrumentorWithParams:
     additional_params: dict[str, typing.Any] = dataclasses.field(default_factory=dict)
 
 
-@dataclasses.dataclass(kw_only=True, slots=True)
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
 class OpenTelemetryInstrument(BaseInstrument):
-    service_version: str = "1.0.0"
-    service_name: str | None = None
     container_name: str | None = None
     endpoint: str | None = None
     namespace: str | None = None
-    insecure: bool = pydantic.Field(default=True)
+    insecure: bool = True
     instrumentors: list[InstrumentorWithParams | BaseInstrumentor] = dataclasses.field(default_factory=list)
+    span_exporter: SpanExporter | None = None
 
-    tracer_provider: TracerProvider = dataclasses.field(init=False)
-
-    def is_ready(self) -> bool:
-        return all(
-            (
-                self.endpoint,
-                self.service_name,
-            ),
-        )
-
-    def teardown(self) -> None:
-        for one_instrumentor in self.instrumentors:
-            if isinstance(one_instrumentor, InstrumentorWithParams):
-                one_instrumentor.instrumentor.uninstrument(**one_instrumentor.additional_params)
-            else:
-                one_instrumentor.uninstrument()
+    def is_ready(self, _: ServiceConfig) -> bool:
+        return bool(self.endpoint)
 
-    def bootstrap(self) -> None:
+    def bootstrap(self, service_config: ServiceConfig, _: ApplicationT | None = None) -> None:
         attributes = {
-            resources.SERVICE_NAME: self.service_name,
+            resources.SERVICE_NAME: service_config.service_name,
             resources.TELEMETRY_SDK_LANGUAGE: "python",
             resources.SERVICE_NAMESPACE: self.namespace,
-            resources.SERVICE_VERSION: self.service_version,
+            resources.SERVICE_VERSION: service_config.service_version,
             resources.CONTAINER_NAME: self.container_name,
         }
         resource: typing.Final = resources.Resource.create(
             attributes={k: v for k, v in attributes.items() if v},
         )
-        self.tracer_provider = TracerProvider(resource=resource)
-        self.tracer_provider.add_span_processor(
+        tracer_provider = TracerProvider(resource=resource)
+        tracer_provider.add_span_processor(
             BatchSpanProcessor(
-                OTLPSpanExporter(
+                self.span_exporter
+                or OTLPSpanExporter(
                     endpoint=self.endpoint,
                     insecure=self.insecure,
                 ),
@@ -67,8 +59,16 @@ class OpenTelemetryInstrument(BaseInstrument):
         for one_instrumentor in self.instrumentors:
             if isinstance(one_instrumentor, InstrumentorWithParams):
                 one_instrumentor.instrumentor.instrument(
-                    tracer_provider=self.tracer_provider,
+                    tracer_provider=tracer_provider,
                     **one_instrumentor.additional_params,
                 )
             else:
-                one_instrumentor.instrument(tracer_provider=self.tracer_provider)
+                one_instrumentor.instrument(tracer_provider=tracer_provider)
+        set_tracer_provider(tracer_provider)
+
+    def teardown(self, _: ApplicationT | None = None) -> None:
+        for one_instrumentor in self.instrumentors:
+            if isinstance(one_instrumentor, InstrumentorWithParams):
+                one_instrumentor.instrumentor.uninstrument(**one_instrumentor.additional_params)
+            else:
+                one_instrumentor.uninstrument()

{lite_bootstrap-0.2.0 → lite_bootstrap-0.4.0}/lite_bootstrap/instruments/sentry_instrument.py

@@ -1,19 +1,22 @@
+import contextlib
 import dataclasses
 import typing
 
-import pydantic
-import sentry_sdk
-from sentry_sdk.integrations import Integration
-
 from lite_bootstrap.instruments.base import BaseInstrument
+from lite_bootstrap.service_config import ServiceConfig
+from lite_bootstrap.types import ApplicationT
+
+
+with contextlib.suppress(ImportError):
+    import sentry_sdk
+    from sentry_sdk.integrations import Integration
 
 
-@dataclasses.dataclass(kw_only=True, slots=True)
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
 class SentryInstrument(BaseInstrument):
     dsn: str | None = None
-    sample_rate: float = pydantic.Field(default=1.0, le=1.0, ge=0.0)
+    sample_rate: float = dataclasses.field(default=1.0)
     traces_sample_rate: float | None = None
-    environment: str | None = None
     max_breadcrumbs: int = 15
     max_value_length: int = 16384
     attach_stacktrace: bool = True
@@ -21,15 +24,15 @@ class SentryInstrument(BaseInstrument):
     additional_params: dict[str, typing.Any] = dataclasses.field(default_factory=dict)
     tags: dict[str, str] | None = None
 
-    def is_ready(self) -> bool:
+    def is_ready(self, _: ServiceConfig) -> bool:
         return bool(self.dsn)
 
-    def bootstrap(self) -> None:
+    def bootstrap(self, service_config: ServiceConfig, _: ApplicationT | None = None) -> None:
         sentry_sdk.init(
             dsn=self.dsn,
             sample_rate=self.sample_rate,
             traces_sample_rate=self.traces_sample_rate,
-            environment=self.environment,
+            environment=service_config.service_environment,
             max_breadcrumbs=self.max_breadcrumbs,
             max_value_length=self.max_value_length,
             attach_stacktrace=self.attach_stacktrace,
@@ -39,4 +42,4 @@ class SentryInstrument(BaseInstrument):
         tags: dict[str, str] = self.tags or {}
         sentry_sdk.set_tags(tags)
 
-    def teardown(self) -> None: ...
+    def teardown(self, application: ApplicationT | None = None) -> None: ...

lite_bootstrap-0.4.0/lite_bootstrap/service_config.py

@@ -0,0 +1,9 @@
+import dataclasses
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class ServiceConfig:
+    service_name: str = "micro-service"
+    service_version: str = "1.0.0"
+    service_environment: str | None = None
+    service_debug: bool = True

lite_bootstrap-0.4.0/lite_bootstrap/types.py

@@ -0,0 +1,4 @@
+import typing
+
+
+ApplicationT = typing.TypeVar("ApplicationT", bound=typing.Any)

{lite_bootstrap-0.2.0 → lite_bootstrap-0.4.0}/pyproject.toml

@@ -43,12 +43,18 @@ otl = [
     "opentelemetry-exporter-otlp",
     "opentelemetry-instrumentation",
 ]
+logging = [
+    "structlog",
+]
 fastapi = [
     "fastapi",
 ]
 fastapi-otl = [
     "opentelemetry-instrumentation-fastapi",
 ]
+fastapi-all = [
+    "lite-bootstrap[sentry,otl,logging,fastapi,fastapi-otl]"
+]
 
 [dependency-groups]
 dev = [

lite_bootstrap-0.4.0/tests/conftest.py

@@ -0,0 +1,36 @@
+import typing
+from unittest.mock import Mock
+
+import pytest
+from fastapi import FastAPI
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor  # type: ignore[attr-defined]
+
+from lite_bootstrap.service_config import ServiceConfig
+
+
+class CustomInstrumentor(BaseInstrumentor):  # type: ignore[misc]
+    def instrumentation_dependencies(self) -> typing.Collection[str]:
+        return []
+
+    def _uninstrument(self, **kwargs: typing.Mapping[str, typing.Any]) -> None:
+        pass
+
+
+@pytest.fixture
+def fastapi_app() -> FastAPI:
+    return FastAPI()
+
+
+@pytest.fixture
+def service_config() -> ServiceConfig:
+    return ServiceConfig(
+        service_name="microservice",
+        service_version="2.0.0",
+        service_environment="test",
+        service_debug=False,
+    )
+
+
+@pytest.fixture(autouse=True)
+def mock_sentry_init(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("sentry_sdk.init", Mock)

lite_bootstrap-0.4.0/tests/instruments/test_logging_instrument.py

@@ -0,0 +1,83 @@
+import logging
+from io import StringIO
+
+import structlog
+from opentelemetry.sdk.trace.export import ConsoleSpanExporter
+from opentelemetry.trace import get_tracer
+
+from lite_bootstrap.instruments.logging_instrument import LoggingInstrument, MemoryLoggerFactory
+from lite_bootstrap.instruments.opentelemetry_instrument import OpenTelemetryInstrument
+from lite_bootstrap.service_config import ServiceConfig
+
+
+logger = structlog.getLogger(__name__)
+
+
+def test_logging_instrument(service_config: ServiceConfig) -> None:
+    logging_instrument = LoggingInstrument(logging_unset_handlers=["uvicorn"], logging_buffer_capacity=0)
+    try:
+        logging_instrument.bootstrap(service_config)
+        logger.info("testing logging", key="value")
+    finally:
+        logging_instrument.teardown()
+
+
+def test_logging_instrument_tracer_injection(service_config: ServiceConfig) -> None:
+    logging_instrument = LoggingInstrument(logging_unset_handlers=["uvicorn"], logging_buffer_capacity=0)
+    opentelemetry_instrument = OpenTelemetryInstrument(
+        endpoint="otl",
+        span_exporter=ConsoleSpanExporter(),
+    )
+    try:
+        logging_instrument.bootstrap(service_config)
+        opentelemetry_instrument.bootstrap(service_config)
+        tracer = get_tracer(__name__)
+        logger.info("testing tracer injection without spans")
+        with tracer.start_as_current_span("my_fake_span") as span:
+            logger.info("testing tracer injection without span attributes")
+            span.set_attribute("example_attribute", "value")
+            span.add_event("example_event", {"event_attr": 1})
+            logger.info("testing tracer injection with span attributes")
+    finally:
+        logging_instrument.teardown()
+        opentelemetry_instrument.teardown()
+
+
+def test_memory_logger_factory_info() -> None:
+    test_capacity = 10
+    test_flush_level = logging.ERROR
+    test_stream = StringIO()
+
+    logger_factory = MemoryLoggerFactory(
+        logging_buffer_capacity=test_capacity,
+        logging_flush_level=test_flush_level,
+        logging_log_level=logging.INFO,
+        log_stream=test_stream,
+    )
+    test_logger = logger_factory()
+    test_message = "test message"
+
+    for current_log_index in range(test_capacity):
+        test_logger.info(test_message)
+        log_contents = test_stream.getvalue()
+        if current_log_index == test_capacity - 1:
+            assert test_message in log_contents
+        else:
+            assert not log_contents
+
+
+def test_memory_logger_factory_error() -> None:
+    test_capacity = 10
+    test_flush_level = logging.ERROR
+    test_stream = StringIO()
+
+    logger_factory = MemoryLoggerFactory(
+        logging_buffer_capacity=test_capacity,
+        logging_flush_level=test_flush_level,
+        logging_log_level=logging.INFO,
+        log_stream=test_stream,
+    )
+    test_logger = logger_factory()
+    error_message = "error message"
+    test_logger.error(error_message)
+    assert error_message in test_stream.getvalue()

lite_bootstrap-0.4.0/tests/instruments/test_opentelemetry_instrument.py

@@ -0,0 +1,31 @@
+from opentelemetry.sdk.trace.export import ConsoleSpanExporter
+
+from lite_bootstrap.instruments.opentelemetry_instrument import InstrumentorWithParams, OpenTelemetryInstrument
+from lite_bootstrap.service_config import ServiceConfig
+from tests.conftest import CustomInstrumentor
+
+
+def test_opentelemetry_instrument(service_config: ServiceConfig) -> None:
+    opentelemetry_instrument = OpenTelemetryInstrument(
+        endpoint="otl",
+        instrumentors=[
+            InstrumentorWithParams(instrumentor=CustomInstrumentor(), additional_params={"key": "value"}),
+            CustomInstrumentor(),
+        ],
+        span_exporter=ConsoleSpanExporter(),
+    )
+    try:
+        opentelemetry_instrument.bootstrap(service_config)
+    finally:
+        opentelemetry_instrument.teardown()
+
+
+def test_opentelemetry_instrument_empty_instruments(service_config: ServiceConfig) -> None:
+    opentelemetry_instrument = OpenTelemetryInstrument(
+        endpoint="otl",
+        span_exporter=ConsoleSpanExporter(),
+    )
+    try:
+        opentelemetry_instrument.bootstrap(service_config)
+    finally:
+        opentelemetry_instrument.teardown()

lite_bootstrap-0.4.0/tests/instruments/test_sentry_instrument.py

@@ -0,0 +1,10 @@
+from lite_bootstrap.instruments.sentry_instrument import SentryInstrument
+from lite_bootstrap.service_config import ServiceConfig
+
+
+def test_sentry_instrument(service_config: ServiceConfig) -> None:
+    SentryInstrument(dsn="https://testdsn@localhost/1", tags={"tag": "value"}).bootstrap(service_config)
+
+
+def test_sentry_instrument_empty_dsn(service_config: ServiceConfig) -> None:
+    SentryInstrument(dsn="").bootstrap(service_config)

lite_bootstrap-0.4.0/tests/test_fastapi_bootstrap.py

@@ -0,0 +1,48 @@
+import structlog
+from fastapi import FastAPI
+from opentelemetry.sdk.trace.export import ConsoleSpanExporter
+from starlette import status
+from starlette.testclient import TestClient
+
+from lite_bootstrap.bootstraps.fastapi_bootstrap import (
+    FastAPIBootstrap,
+    FastAPIHealthChecksInstrument,
+    FastAPILoggingInstrument,
+    FastAPIOpenTelemetryInstrument,
+    FastAPISentryInstrument,
+)
+from lite_bootstrap.service_config import ServiceConfig
+from tests.conftest import CustomInstrumentor
+
+
+logger = structlog.getLogger(__name__)
+
+
+def test_fastapi_bootstrap(fastapi_app: FastAPI, service_config: ServiceConfig) -> None:
+    fastapi_bootstrap = FastAPIBootstrap(
+        application=fastapi_app,
+        service_config=service_config,
+        instruments=[
+            FastAPIOpenTelemetryInstrument(
+                endpoint="otl",
+                instrumentors=[CustomInstrumentor()],
+                span_exporter=ConsoleSpanExporter(),
+            ),
+            FastAPISentryInstrument(
+                dsn="https://testdsn@localhost/1",
+            ),
+            FastAPIHealthChecksInstrument(
+                path="/health/",
+            ),
+            FastAPILoggingInstrument(logging_buffer_capacity=0),
+        ],
+    )
+    fastapi_bootstrap.bootstrap()
+    logger.info("testing logging", key="value")
+
+    try:
+        response = TestClient(fastapi_app).get("/health/")
+        assert response.status_code == status.HTTP_200_OK
+        assert response.json() == {"health_status": True, "service_name": "microservice", "service_version": "2.0.0"}
+    finally:
+        fastapi_bootstrap.teardown()

lite_bootstrap-0.2.0/lite_bootstrap/bootstraps/base.py

@@ -1,18 +0,0 @@
-import abc
-import typing
-
-from lite_bootstrap.instruments.base import BaseInstrument
-
-
-class BaseBootstrap(abc.ABC):
-    instruments: typing.Sequence[BaseInstrument]
-
-    def bootstrap(self) -> None:
-        for one_instrument in self.instruments:
-            if one_instrument.is_ready():
-                one_instrument.bootstrap()
-
-    def teardown(self) -> None:
-        for one_instrument in self.instruments:
-            if one_instrument.is_ready():
-                one_instrument.teardown()

lite_bootstrap-0.2.0/lite_bootstrap/bootstraps/fastapi_bootstrap.py

@@ -1,51 +0,0 @@
-import dataclasses
-import typing
-
-import fastapi
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
-from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
-
-from lite_bootstrap.bootstraps.base import BaseBootstrap
-from lite_bootstrap.instruments.opentelemetry_instrument import OpenTelemetryInstrument
-from lite_bootstrap.instruments.sentry_instrument import SentryInstrument
-
-
-@dataclasses.dataclass(kw_only=True)
-class FastAPIOpenTelemetryInstrument(OpenTelemetryInstrument):
-    excluded_urls: list[str] = dataclasses.field(default_factory=list)
-    app: fastapi.FastAPI = dataclasses.field(init=False)
-
-    def bootstrap(self) -> None:
-        super().bootstrap()
-        FastAPIInstrumentor.instrument_app(
-            app=self.app,
-            tracer_provider=self.tracer_provider,
-            excluded_urls=",".join(self.excluded_urls),
-        )
-
-    def teardown(self) -> None:
-        FastAPIInstrumentor.uninstrument_app(self.app)
-        super().teardown()
-
-
-@dataclasses.dataclass(kw_only=True)
-class FastAPISentryInstrument(SentryInstrument):
-    app: fastapi.FastAPI = dataclasses.field(init=False)
-
-    def bootstrap(self) -> None:
-        super().bootstrap()
-        self.app.add_middleware(SentryAsgiMiddleware)  # type: ignore[arg-type]
-
-    def teardown(self) -> None:
-        FastAPIInstrumentor.uninstrument_app(self.app)
-        super().teardown()
-
-
-@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
-class FastAPIBootstrap(BaseBootstrap):
-    app: fastapi.FastAPI
-    instruments: typing.Sequence[FastAPIOpenTelemetryInstrument | FastAPISentryInstrument]
-
-    def __post_init__(self) -> None:
-        for one_instrument in self.instruments:
-            one_instrument.app = self.app

lite_bootstrap-0.2.0/lite_bootstrap/instruments/base.py

@@ -1,12 +0,0 @@
-import abc
-
-
-class BaseInstrument(abc.ABC):
-    @abc.abstractmethod
-    def bootstrap(self) -> None: ...
-
-    @abc.abstractmethod
-    def teardown(self) -> None: ...
-
-    @abc.abstractmethod
-    def is_ready(self) -> bool: ...

lite_bootstrap-0.2.0/tests/conftest.py

@@ -1,27 +0,0 @@
-import typing
-
-import pytest
-from fastapi import APIRouter, FastAPI
-from fastapi.responses import JSONResponse
-from opentelemetry.instrumentation.instrumentor import BaseInstrumentor  # type: ignore[attr-defined]
-
-
-class CustomInstrumentor(BaseInstrumentor):  # type: ignore[misc]
-    def instrumentation_dependencies(self) -> typing.Collection[str]:
-        return []
-
-    def _uninstrument(self, **kwargs: typing.Mapping[str, typing.Any]) -> None:
-        pass
-
-
-@pytest.fixture
-def fastapi_app() -> FastAPI:
-    app: typing.Final = FastAPI()
-    router: typing.Final = APIRouter()
-
-    @router.get("/test")
-    async def for_test_endpoint() -> JSONResponse:
-        return JSONResponse(content={"key": "value"})
-
-    app.include_router(router)
-    return app

lite_bootstrap-0.2.0/tests/test_fastapi_bootstrap.py

@@ -1,33 +0,0 @@
-from fastapi import FastAPI
-from starlette import status
-from starlette.testclient import TestClient
-
-from lite_bootstrap.bootstraps.fastapi_bootstrap import (
-    FastAPIBootstrap,
-    FastAPIOpenTelemetryInstrument,
-    FastAPISentryInstrument,
-)
-from tests.conftest import CustomInstrumentor
-
-
-def test_fastapi_bootstrap(fastapi_app: FastAPI) -> None:
-    fastapi_bootstrap = FastAPIBootstrap(
-        app=fastapi_app,
-        instruments=[
-            FastAPIOpenTelemetryInstrument(
-                endpoint="localhost",
-                service_name="test_service",
-                instrumentors=[CustomInstrumentor()],
-            ),
-            FastAPISentryInstrument(
-                dsn="https://testdsn@test.sentry.com/1",
-            ),
-        ],
-    )
-    fastapi_bootstrap.bootstrap()
-    fastapi_bootstrap.teardown()
-
-    response = TestClient(fastapi_app).get("/test")
-    assert response.status_code == status.HTTP_200_OK
-
-    fastapi_bootstrap.teardown()

lite_bootstrap-0.2.0/tests/test_opentelemetry_bootstrap.py

@@ -1,24 +0,0 @@
-from lite_bootstrap.instruments.opentelemetry_instrument import InstrumentorWithParams, OpenTelemetryInstrument
-from tests.conftest import CustomInstrumentor
-
-
-def test_bootstrap_opentelemetry() -> None:
-    opentelemetry = OpenTelemetryInstrument(
-        endpoint="localhost",
-        service_name="test_service",
-        instrumentors=[
-            InstrumentorWithParams(instrumentor=CustomInstrumentor(), additional_params={"key": "value"}),
-            CustomInstrumentor(),
-        ],
-    )
-    opentelemetry.bootstrap()
-    opentelemetry.teardown()
-
-
-def test_bootstrap_opentelemetry_empty_instruments() -> None:
-    opentelemetry = OpenTelemetryInstrument(
-        endpoint="localhost",
-        service_name="test_service",
-    )
-    opentelemetry.bootstrap()
-    opentelemetry.teardown()

lite_bootstrap-0.2.0/tests/test_sentry_bootstrap.py

@@ -1,9 +0,0 @@
-from lite_bootstrap.instruments.sentry_instrument import SentryInstrument
-
-
-def test_sentry_bootstrap() -> None:
-    SentryInstrument(dsn="https://testdsn@test.sentry.com/1", tags={"tag": "value"}).bootstrap()
-
-
-def test_sentry_bootstrap_empty_dsn() -> None:
-    SentryInstrument(dsn="").bootstrap()