lite-bootstrap 1.2.2__tar.gz → 1.3.0__tar.gz

{lite_bootstrap-1.2.2 → lite_bootstrap-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lite-bootstrap
-Version: 1.2.2
+Version: 1.3.0
 Summary: Lightweight bootstrap for production-ready Python microservices
 Keywords: microservices,bootstrap,opentelemetry,sentry,error-tracing,fastapi,litestar,faststream,structlog,fastmcp,python
 Author: Artur Shiriev
@@ -15,7 +15,6 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
 Classifier: Topic :: Software Development :: Libraries
-Requires-Dist: orjson
 Requires-Dist: fastapi ; extra == 'fastapi'
 Requires-Dist: lite-bootstrap[fastapi-sentry,fastapi-otl,fastapi-logging,fastapi-metrics,pyroscope] ; extra == 'fastapi-all'
 Requires-Dist: lite-bootstrap[fastapi,logging] ; extra == 'fastapi-logging'
@@ -46,10 +45,15 @@ Requires-Dist: lite-bootstrap[litestar,otl] ; extra == 'litestar-otl'
 Requires-Dist: opentelemetry-instrumentation-asgi>=0.46b0 ; extra == 'litestar-otl'
 Requires-Dist: lite-bootstrap[litestar,sentry] ; extra == 'litestar-sentry'
 Requires-Dist: structlog ; extra == 'logging'
+Requires-Dist: orjson ; extra == 'orjson'
 Requires-Dist: opentelemetry-api ; extra == 'otl'
 Requires-Dist: opentelemetry-sdk ; extra == 'otl'
-Requires-Dist: opentelemetry-exporter-otlp ; extra == 'otl'
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc ; extra == 'otl'
 Requires-Dist: opentelemetry-instrumentation ; extra == 'otl'
+Requires-Dist: opentelemetry-api ; extra == 'otl-http'
+Requires-Dist: opentelemetry-sdk ; extra == 'otl-http'
+Requires-Dist: opentelemetry-exporter-otlp-proto-http ; extra == 'otl-http'
+Requires-Dist: opentelemetry-instrumentation ; extra == 'otl-http'
 Requires-Dist: pyroscope-io ; extra == 'pyroscope'
 Requires-Dist: sentry-sdk ; extra == 'sentry'
 Requires-Python: >=3.10, <4
@@ -81,7 +85,9 @@ Provides-Extra: litestar-metrics
 Provides-Extra: litestar-otl
 Provides-Extra: litestar-sentry
 Provides-Extra: logging
+Provides-Extra: orjson
 Provides-Extra: otl
+Provides-Extra: otl-http
 Provides-Extra: pyroscope
 Provides-Extra: sentry
 Description-Content-Type: text/markdown
@@ -109,6 +115,7 @@ Description-Content-Type: text/markdown
 `lite-bootstrap` wires production observability — OpenTelemetry, Prometheus, Sentry, and structlog — into FastAPI, Litestar, and FastStream services in a few lines, with no boilerplate.
 
 With `lite-bootstrap`, you receive an application with lightweight built-in support for:
+
 - `sentry`
 - `prometheus`
 - `opentelemetry`
@@ -120,11 +127,11 @@ With `lite-bootstrap`, you receive an application with lightweight built-in supp
 
 Those instruments can be bootstrapped for:
 
-- [LiteStar](https://lite-bootstrap.modern-python.org/integrations/litestar)
-- [FastStream](https://lite-bootstrap.modern-python.org/integrations/faststream)
-- [FastAPI](https://lite-bootstrap.modern-python.org/integrations/fastapi)
-- [FastMCP](https://lite-bootstrap.modern-python.org/integrations/fastmcp)
-- [services and scripts without frameworks](https://lite-bootstrap.modern-python.org/integrations/free)
+- [LiteStar](https://lite-bootstrap.modern-python.org/integrations/litestar/)
+- [FastStream](https://lite-bootstrap.modern-python.org/integrations/faststream/)
+- [FastAPI](https://lite-bootstrap.modern-python.org/integrations/fastapi/)
+- [FastMCP](https://lite-bootstrap.modern-python.org/integrations/fastmcp/)
+- [services and scripts without frameworks](https://lite-bootstrap.modern-python.org/integrations/free/)
 
 ## Lifecycle constraints
 
@@ -155,7 +162,7 @@ The following ideas were borrowed:
 The following intentionally differ:
 
 - **Configuration**: `lite-bootstrap` uses frozen `dataclass` configs (no `pydantic` / `pydantic-settings` runtime dependency), which is what makes it "lite". `microbootstrap` configures everything through `pydantic-settings` models.
-- **Granular extras**: `lite-bootstrap` ships only `orjson` as a runtime dependency; every instrument (`sentry`, `otl`, `logging`, `pyroscope`) and every framework (`fastapi`, `litestar`, `faststream`) is its own extra, with per-pair combos (`fastapi-sentry`, `litestar-otl`, `faststream-metrics`, …) and `*-all` rollups. You install only what you actually use. `microbootstrap` bundles the full observability stack (opentelemetry, sentry-sdk, structlog, pyroscope-io, rich, pydantic-settings, …) as base dependencies and only splits framework packages into extras.
+- **Granular extras**: `lite-bootstrap` has **no** mandatory runtime dependencies; every instrument (`sentry`, `otl`, `logging`, `pyroscope`) and every framework (`fastapi`, `litestar`, `faststream`) is its own extra, plus an opt-in `orjson` speedup for logging, per-pair combos (`fastapi-sentry`, `litestar-otl`, `faststream-metrics`, …) and `*-all` rollups. You install only what you actually use. It also runs on free-threaded CPython (3.13t/3.14t) — see [`architecture/free-threading.md`](architecture/free-threading.md). `microbootstrap` bundles the full observability stack (opentelemetry, sentry-sdk, structlog, pyroscope-io, rich, pydantic-settings, …) as base dependencies and only splits framework packages into extras.
 - **Scope**: `lite-bootstrap` is deliberately narrow — only instrument wiring. It does not include a Granian server runner or a console writer.
 
 ## 📚 [Documentation](https://lite-bootstrap.modern-python.org)

{lite_bootstrap-1.2.2 → lite_bootstrap-1.3.0}/README.md

@@ -21,6 +21,7 @@
 `lite-bootstrap` wires production observability — OpenTelemetry, Prometheus, Sentry, and structlog — into FastAPI, Litestar, and FastStream services in a few lines, with no boilerplate.
 
 With `lite-bootstrap`, you receive an application with lightweight built-in support for:
+
 - `sentry`
 - `prometheus`
 - `opentelemetry`
@@ -32,11 +33,11 @@ With `lite-bootstrap`, you receive an application with lightweight built-in supp
 
 Those instruments can be bootstrapped for:
 
-- [LiteStar](https://lite-bootstrap.modern-python.org/integrations/litestar)
-- [FastStream](https://lite-bootstrap.modern-python.org/integrations/faststream)
-- [FastAPI](https://lite-bootstrap.modern-python.org/integrations/fastapi)
-- [FastMCP](https://lite-bootstrap.modern-python.org/integrations/fastmcp)
-- [services and scripts without frameworks](https://lite-bootstrap.modern-python.org/integrations/free)
+- [LiteStar](https://lite-bootstrap.modern-python.org/integrations/litestar/)
+- [FastStream](https://lite-bootstrap.modern-python.org/integrations/faststream/)
+- [FastAPI](https://lite-bootstrap.modern-python.org/integrations/fastapi/)
+- [FastMCP](https://lite-bootstrap.modern-python.org/integrations/fastmcp/)
+- [services and scripts without frameworks](https://lite-bootstrap.modern-python.org/integrations/free/)
 
 ## Lifecycle constraints
 
@@ -67,7 +68,7 @@ The following ideas were borrowed:
 The following intentionally differ:
 
 - **Configuration**: `lite-bootstrap` uses frozen `dataclass` configs (no `pydantic` / `pydantic-settings` runtime dependency), which is what makes it "lite". `microbootstrap` configures everything through `pydantic-settings` models.
-- **Granular extras**: `lite-bootstrap` ships only `orjson` as a runtime dependency; every instrument (`sentry`, `otl`, `logging`, `pyroscope`) and every framework (`fastapi`, `litestar`, `faststream`) is its own extra, with per-pair combos (`fastapi-sentry`, `litestar-otl`, `faststream-metrics`, …) and `*-all` rollups. You install only what you actually use. `microbootstrap` bundles the full observability stack (opentelemetry, sentry-sdk, structlog, pyroscope-io, rich, pydantic-settings, …) as base dependencies and only splits framework packages into extras.
+- **Granular extras**: `lite-bootstrap` has **no** mandatory runtime dependencies; every instrument (`sentry`, `otl`, `logging`, `pyroscope`) and every framework (`fastapi`, `litestar`, `faststream`) is its own extra, plus an opt-in `orjson` speedup for logging, per-pair combos (`fastapi-sentry`, `litestar-otl`, `faststream-metrics`, …) and `*-all` rollups. You install only what you actually use. It also runs on free-threaded CPython (3.13t/3.14t) — see [`architecture/free-threading.md`](architecture/free-threading.md). `microbootstrap` bundles the full observability stack (opentelemetry, sentry-sdk, structlog, pyroscope-io, rich, pydantic-settings, …) as base dependencies and only splits framework packages into extras.
 - **Scope**: `lite-bootstrap` is deliberately narrow — only instrument wiring. It does not include a Granian server runner or a console writer.
 
 ## 📚 [Documentation](https://lite-bootstrap.modern-python.org)

{lite_bootstrap-1.2.2 → lite_bootstrap-1.3.0}/lite_bootstrap/bootstrappers/faststream_bootstrapper.py

@@ -43,6 +43,11 @@ class FastStreamTelemetryMiddlewareProtocol(typing.Protocol):
         include_messages_counters: bool = True,
     ) -> None: ...
 
+    # A constructed instance is passed to broker.add_middleware, which expects a
+    # faststream BrokerMiddleware — a builder callable. Declared with Any to keep
+    # lite-bootstrap decoupled from faststream's internal middleware types.
+    def __call__(self, msg: typing.Any, /, *, context: typing.Any) -> typing.Any: ...  # noqa: ANN401
+
 
 @typing.runtime_checkable
 class FastStreamPrometheusMiddlewareProtocol(typing.Protocol):
@@ -55,6 +60,9 @@ class FastStreamPrometheusMiddlewareProtocol(typing.Protocol):
         received_messages_size_buckets: typing.Sequence[float] | None = None,
     ) -> None: ...
 
+    # See FastStreamTelemetryMiddlewareProtocol.__call__.
+    def __call__(self, msg: typing.Any, /, *, context: typing.Any) -> typing.Any: ...  # noqa: ANN401
+
 
 def _make_asgi_faststream() -> "AsgiFastStream":
     return AsgiFastStream()

lite_bootstrap-1.3.0/lite_bootstrap/import_checker.py

@@ -0,0 +1,40 @@
+from importlib.util import find_spec
+
+
+def _safe_find_spec(module_name: str) -> bool:
+    """Return whether a dotted module is importable, treating a missing parent as absent.
+
+    find_spec imports the dotted name's parent first; a present-but-incomplete
+    namespace (e.g. opentelemetry-api installed without opentelemetry-instrumentation)
+    otherwise raises ModuleNotFoundError, crashing `import lite_bootstrap`.
+    """
+    try:
+        return find_spec(module_name) is not None
+    except ModuleNotFoundError:
+        return False
+
+
+is_opentelemetry_installed = find_spec("opentelemetry") is not None
+# opentelemetry-api provides the `opentelemetry` namespace (trace, metrics) without the
+# sdk. The OTel instrument imports opentelemetry.sdk.* and needs this stricter check;
+# api-only consumers (logging trace-injection, framework get_tracer_provider) use the
+# flag above. See architecture/instruments.md.
+is_opentelemetry_sdk_installed = _safe_find_spec("opentelemetry.sdk")
+is_sentry_installed = find_spec("sentry_sdk") is not None
+is_structlog_installed = find_spec("structlog") is not None
+is_prometheus_client_installed = find_spec("prometheus_client") is not None
+is_fastapi_installed = find_spec("fastapi") is not None
+is_litestar_installed = find_spec("litestar") is not None
+is_faststream_installed = find_spec("faststream") is not None
+is_prometheus_fastapi_instrumentator_installed = find_spec("prometheus_fastapi_instrumentator") is not None
+is_fastapi_opentelemetry_installed = is_opentelemetry_installed and _safe_find_spec(
+    "opentelemetry.instrumentation.fastapi"
+)
+is_litestar_opentelemetry_installed = (
+    is_opentelemetry_installed and is_litestar_installed and _safe_find_spec("opentelemetry.instrumentation.asgi")
+)
+is_otlp_grpc_exporter_installed = _safe_find_spec("opentelemetry.exporter.otlp.proto.grpc.trace_exporter")
+is_otlp_http_exporter_installed = _safe_find_spec("opentelemetry.exporter.otlp.proto.http.trace_exporter")
+is_pyroscope_installed = find_spec("pyroscope") is not None
+is_fastmcp_installed = find_spec("fastmcp") is not None
+is_orjson_installed = find_spec("orjson") is not None

{lite_bootstrap-1.2.2 → lite_bootstrap-1.3.0}/lite_bootstrap/instruments/logging_factory.py

@@ -1,14 +1,17 @@
 import dataclasses
+import json
 import logging
 import logging.handlers
 import sys
 import typing
 
-import orjson
-
 from lite_bootstrap import import_checker
 
 
+if import_checker.is_orjson_installed:
+    import orjson
+
+
 ScopeType = typing.MutableMapping[str, typing.Any]
 
 
@@ -31,10 +34,22 @@ class _MemoryLoggerFactoryConfig:
     log_stream: typing.Any = sys.stdout
 
 
-def _serialize_log_with_orjson_to_string(value: typing.Any, **kwargs: typing.Any) -> str:  # noqa: ANN401
+def _dumps_orjson(value: typing.Any, **kwargs: typing.Any) -> str:  # noqa: ANN401
     return orjson.dumps(value, **kwargs).decode()
 
 
+def _dumps_stdlib(value: typing.Any, **kwargs: typing.Any) -> str:  # noqa: ANN401
+    # Match orjson's compact, UTF-8 output shape so log lines stay byte-identical.
+    return json.dumps(value, separators=(",", ":"), ensure_ascii=False, **kwargs)
+
+
+# orjson has no free-threaded wheels and refuses to build on ft; fall back to the
+# stdlib json accelerator (always ft-native) when it is absent.
+# See architecture/free-threading.md.
+_serialize_log_to_string = _dumps_orjson if import_checker.is_orjson_installed else _dumps_stdlib
+_json_loads = orjson.loads if import_checker.is_orjson_installed else json.loads
+
+
 # Meta-keys the producer's structlog processor chain emits at the top level of every
 # rendered line (see lite_bootstrap/instruments/logging_instrument.py). They are not
 # user-supplied extra and are stripped from StructuredLogPayload.extra. If you add a
@@ -68,8 +83,8 @@ class StructuredLogPayload:
         if not formatted.startswith("{"):
             return None
         try:
-            loaded = orjson.loads(formatted)
-        except orjson.JSONDecodeError:
+            loaded = _json_loads(formatted)
+        except json.JSONDecodeError:  # orjson.JSONDecodeError subclasses this
             return None
         if not isinstance(loaded, dict):  # pragma: no cover - JSON starting with "{" is always an object
             return None

{lite_bootstrap-1.2.2 → lite_bootstrap-1.3.0}/lite_bootstrap/instruments/logging_instrument.py

@@ -11,7 +11,7 @@ from lite_bootstrap.instruments.logging_factory import (
     RequestProtocol,
     ScopeType,
     _MemoryLoggerFactoryConfig,
-    _serialize_log_with_orjson_to_string,
+    _serialize_log_to_string,
 )
 
 
@@ -117,7 +117,7 @@ class LoggingInstrument(BaseInstrument[LoggingConfig]):
             structlog.stdlib.filter_by_level,
             *self.structlog_pre_chain_processors,
             *self.bootstrap_config.logging_extra_processors,
-            structlog.processors.JSONRenderer(serializer=_serialize_log_with_orjson_to_string),
+            structlog.processors.JSONRenderer(serializer=_serialize_log_to_string),
         ]
 
     @property
@@ -152,7 +152,7 @@ class LoggingInstrument(BaseInstrument[LoggingConfig]):
                 processors=[
                     structlog.stdlib.ProcessorFormatter.remove_processors_meta,
                     *self.bootstrap_config.logging_extra_processors,
-                    structlog.processors.JSONRenderer(serializer=_serialize_log_with_orjson_to_string),
+                    structlog.processors.JSONRenderer(serializer=_serialize_log_to_string),
                 ],
                 logger=root_logger,
             )

{lite_bootstrap-1.2.2 → lite_bootstrap-1.3.0}/lite_bootstrap/instruments/opentelemetry_instrument.py

@@ -6,21 +6,29 @@ import urllib.parse
 import warnings
 
 from lite_bootstrap import import_checker
-from lite_bootstrap.exceptions import TeardownError
+from lite_bootstrap.exceptions import InstrumentDependencyMissingWarning, TeardownError
 from lite_bootstrap.instruments.base import BaseConfig, BaseInstrument
 
 
 if typing.TYPE_CHECKING:
     from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 
-if import_checker.is_opentelemetry_installed:
+if import_checker.is_opentelemetry_sdk_installed:
     from opentelemetry.context import Context
-    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
     from opentelemetry.sdk import resources
     from opentelemetry.sdk.trace import ReadableSpan, SpanProcessor, TracerProvider
     from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter, SimpleSpanProcessor
     from opentelemetry.trace import Span, format_span_id, set_tracer_provider
 
+if import_checker.is_otlp_grpc_exporter_installed:
+    # opentelemetry-api can be present without the grpc otlp exporter package (e.g.
+    # lite-bootstrap[fastmcp] pulls bare opentelemetry-api transitively); this must
+    # stay a separate guard from is_opentelemetry_installed above.
+    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter as OTLPGrpcSpanExporter
+
+if import_checker.is_otlp_http_exporter_installed:
+    from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter as OTLPHttpSpanExporter
+
 if import_checker.is_pyroscope_installed:
     import pyroscope
 
@@ -51,6 +59,7 @@ class OpenTelemetryConfig(OpenTelemetryServiceFieldsConfig):
     )
     opentelemetry_endpoint: str | None = None
     opentelemetry_insecure: bool = True
+    opentelemetry_exporter_protocol: typing.Literal["grpc", "http"] = "grpc"
     opentelemetry_instrumentors: list[typing.Union[InstrumentorWithParams, "BaseInstrumentor"]] = dataclasses.field(
         default_factory=list
     )
@@ -70,6 +79,8 @@ class OpenTelemetryConfig(OpenTelemetryServiceFieldsConfig):
 
     def _parse_remote_insecure_host(self) -> str | None:
         """Return the host name if the endpoint is insecure AND non-local; else None."""
+        if self.opentelemetry_exporter_protocol != "grpc":
+            return None
         if not self.opentelemetry_endpoint or not self.opentelemetry_insecure:
             return None
         if self.opentelemetry_endpoint.startswith("unix://"):
@@ -86,7 +97,7 @@ class OpenTelemetryConfig(OpenTelemetryServiceFieldsConfig):
         return host
 
 
-if import_checker.is_opentelemetry_installed and import_checker.is_pyroscope_installed:
+if import_checker.is_opentelemetry_sdk_installed and import_checker.is_pyroscope_installed:
     _OTEL_PROFILE_ID_KEY: typing.Final = "pyroscope.profile.id"
     _PYROSCOPE_SPAN_ID_KEY: typing.Final = "span_id"
     _PYROSCOPE_SPAN_NAME_KEY: typing.Final = "span_name"
@@ -126,7 +137,7 @@ class OpenTelemetryInstrument(BaseInstrument[OpenTelemetryConfig]):
     """
 
     not_ready_message = "opentelemetry_endpoint is empty and opentelemetry_log_traces is False"
-    missing_dependency_message = "opentelemetry is not installed"
+    missing_dependency_message = "opentelemetry-sdk is not installed"
     _tracer_provider: "TracerProvider | None" = dataclasses.field(
         default_factory=lambda: None, init=False, repr=False, compare=False
     )
@@ -140,7 +151,9 @@ class OpenTelemetryInstrument(BaseInstrument[OpenTelemetryConfig]):
 
     @staticmethod
     def check_dependencies() -> bool:
-        return import_checker.is_opentelemetry_installed
+        # The instrument imports from both the api (opentelemetry.trace/.context) and
+        # the sdk (opentelemetry.sdk.*), so it needs both distributions present.
+        return import_checker.is_opentelemetry_installed and import_checker.is_opentelemetry_sdk_installed
 
     def _build_excluded_urls(self) -> set[str]:
         excluded_urls: set[str] = set(self.bootstrap_config.opentelemetry_excluded_urls)
@@ -176,15 +189,37 @@ class OpenTelemetryInstrument(BaseInstrument[OpenTelemetryConfig]):
             tracer_provider.add_span_processor(PyroscopeSpanProcessor())
         if self.bootstrap_config.opentelemetry_log_traces:
             tracer_provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter(formatter=_format_span)))
-        if self.bootstrap_config.opentelemetry_endpoint:  # pragma: no cover
-            tracer_provider.add_span_processor(
-                BatchSpanProcessor(
-                    OTLPSpanExporter(
-                        endpoint=self.bootstrap_config.opentelemetry_endpoint,
-                        insecure=self.bootstrap_config.opentelemetry_insecure,
+        if self.bootstrap_config.opentelemetry_endpoint:
+            if self.bootstrap_config.opentelemetry_exporter_protocol == "grpc":
+                if import_checker.is_otlp_grpc_exporter_installed:
+                    tracer_provider.add_span_processor(
+                        BatchSpanProcessor(
+                            OTLPGrpcSpanExporter(
+                                endpoint=self.bootstrap_config.opentelemetry_endpoint,
+                                insecure=self.bootstrap_config.opentelemetry_insecure,
+                            ),
+                        ),
+                    )
+                else:
+                    warnings.warn(
+                        "opentelemetry_endpoint is set but the gRPC OTLP exporter is not installed; "
+                        "spans will not be exported. Install lite-bootstrap[otl].",
+                        category=InstrumentDependencyMissingWarning,
+                        stacklevel=2,
+                    )
+            elif import_checker.is_otlp_http_exporter_installed:
+                tracer_provider.add_span_processor(
+                    BatchSpanProcessor(
+                        OTLPHttpSpanExporter(endpoint=self.bootstrap_config.opentelemetry_endpoint),
                     ),
-                ),
-            )
+                )
+            else:
+                warnings.warn(
+                    "opentelemetry_endpoint is set but the HTTP OTLP exporter is not installed; "
+                    "spans will not be exported. Install lite-bootstrap[otl-http].",
+                    category=InstrumentDependencyMissingWarning,
+                    stacklevel=2,
+                )
         for one_instrumentor in self.bootstrap_config.opentelemetry_instrumentors:
             if isinstance(one_instrumentor, InstrumentorWithParams):
                 one_instrumentor.instrumentor.instrument(

{lite_bootstrap-1.2.2 → lite_bootstrap-1.3.0}/pyproject.toml

@@ -19,10 +19,8 @@ classifiers = [
     "Typing :: Typed",
     "Topic :: Software Development :: Libraries",
 ]
-version = "1.2.2"
-dependencies = [
-    "orjson",
-]
+version = "1.3.0"
+dependencies = []
 
 [project.urls]
 Homepage = "https://lite-bootstrap.modern-python.org"
@@ -32,6 +30,9 @@ Issues = "https://github.com/modern-python/lite-bootstrap/issues"
 Changelog = "https://github.com/modern-python/lite-bootstrap/releases"
 
 [project.optional-dependencies]
+orjson = [
+    "orjson",
+]
 sentry = [
     "sentry-sdk",
 ]
@@ -41,7 +42,13 @@ pyroscope = [
 otl = [
     "opentelemetry-api",
     "opentelemetry-sdk",
-    "opentelemetry-exporter-otlp",
+    "opentelemetry-exporter-otlp-proto-grpc",
+    "opentelemetry-instrumentation",
+]
+otl-http = [
+    "opentelemetry-api",
+    "opentelemetry-sdk",
+    "opentelemetry-exporter-otlp-proto-http",
     "opentelemetry-instrumentation",
 ]
 logging = [
@@ -170,6 +177,9 @@ ignore = [
 isort.lines-after-imports = 2
 isort.no-lines-before = ["standard-library", "local-folder"]
 
+[tool.ruff.lint.per-file-ignores]
+"scripts/*.py" = ["INP001"] # standalone scripts, not an importable package
+
 [tool.pytest.ini_options]
 addopts = "--cov=. --cov-report term-missing --cov-fail-under=100"
 asyncio_mode = "auto"

lite_bootstrap-1.2.2/lite_bootstrap/import_checker.py

@@ -1,19 +0,0 @@
-from importlib.util import find_spec
-
-
-is_opentelemetry_installed = find_spec("opentelemetry") is not None
-is_sentry_installed = find_spec("sentry_sdk") is not None
-is_structlog_installed = find_spec("structlog") is not None
-is_prometheus_client_installed = find_spec("prometheus_client") is not None
-is_fastapi_installed = find_spec("fastapi") is not None
-is_litestar_installed = find_spec("litestar") is not None
-is_faststream_installed = find_spec("faststream") is not None
-is_prometheus_fastapi_instrumentator_installed = find_spec("prometheus_fastapi_instrumentator") is not None
-is_fastapi_opentelemetry_installed = (
-    is_opentelemetry_installed and find_spec("opentelemetry.instrumentation.fastapi") is not None
-)
-is_litestar_opentelemetry_installed = (
-    is_opentelemetry_installed and is_litestar_installed and find_spec("opentelemetry.instrumentation.asgi") is not None
-)
-is_pyroscope_installed = find_spec("pyroscope") is not None
-is_fastmcp_installed = find_spec("fastmcp") is not None