implement new version

Author: lesnik512

.github/workflows/ci.yml

@@ -14,12 +14,13 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: "3.10"
+      - uses: actions/checkout@v4
       - uses: extractions/setup-just@v2
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+          cache-dependency-glob: "**/pyproject.toml"
+      - run: uv python install 3.10
       - run: just install lint-ci
 
   pytest:
@@ -31,16 +32,18 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
+          - "3.13"
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
+      - uses: actions/checkout@v4
       - uses: extractions/setup-just@v2
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
-      - run: just install test . --cov=. --cov-report xml
-      - name: Upload coverage to Codecov
-        uses: codecov/[email protected]
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+          cache-dependency-glob: "**/pyproject.toml"
+      - run: uv python install ${{ matrix.python-version }}
+      - run: just install
+      - run: just test . --cov=. --cov-report xml
+      - uses: codecov/[email protected]
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
         with:

.github/workflows/publish.yml

@@ -10,15 +10,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - uses: actions/cache@v4
-        with:
-          path: ~/.cache/uv
-          key: publish-${{ hashFiles('pyproject.toml') }}
       - uses: extractions/setup-just@v2
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+          cache-dependency-glob: "**/pyproject.toml"
       - run: just publish
         env:
           PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}

Justfile

@@ -5,20 +5,25 @@ install:
     uv sync --all-extras --frozen
 
 lint:
-    uv run ruff format .
-    uv run ruff check . --fix
+    uv run ruff format
+    uv run ruff check --fix
     uv run mypy .
 
 lint-ci:
-    uv run ruff format . --check
-    uv run ruff check . --no-fix
+    uv run ruff format --check
+    uv run ruff check --no-fix
     uv run mypy .
 
 test *args:
-    uv run pytest {{ args }}
+    uv run --no-sync pytest {{ args }}
 
 publish:
-    rm -rf dist/*
-    uv tool run --from build python -m build --installer uv
-    uv tool run twine check dist/*
-    uv tool run twine upload dist/* --username __token__ --password $PYPI_TOKEN
+    rm -rf dist
+    uv build
+    uv publish --token $PYPI_TOKEN
+
+hook:
+    uv run pre-commit install
+
+unhook:
+    uv run pre-commit uninstall

lite_bootstrap/bootstraps/__init__.py

@@ -0,0 +1,18 @@
+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/bootstraps/base.py

@@ -0,0 +1,51 @@
+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/bootstraps/fastapi_bootstrap.py

@@ -0,0 +1,12 @@
+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/fastapi_bootstrap.py

@@ -0,0 +1,74 @@
+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 lite_bootstrap.instruments.base import BaseInstrument
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class InstrumentorWithParams:
+    instrumentor: BaseInstrumentor
+    additional_params: dict[str, typing.Any] = dataclasses.field(default_factory=dict)
+
+
+@dataclasses.dataclass(kw_only=True, slots=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)
+    instrumentors: list[InstrumentorWithParams | BaseInstrumentor] = dataclasses.field(default_factory=list)
+
+    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 bootstrap(self) -> None:
+        attributes = {
+            resources.SERVICE_NAME: self.service_name,
+            resources.TELEMETRY_SDK_LANGUAGE: "python",
+            resources.SERVICE_NAMESPACE: self.namespace,
+            resources.SERVICE_VERSION: self.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(
+            BatchSpanProcessor(
+                OTLPSpanExporter(
+                    endpoint=self.endpoint,
+                    insecure=self.insecure,
+                ),
+            ),
+        )
+        for one_instrumentor in self.instrumentors:
+            if isinstance(one_instrumentor, InstrumentorWithParams):
+                one_instrumentor.instrumentor.instrument(
+                    tracer_provider=self.tracer_provider,
+                    **one_instrumentor.additional_params,
+                )
+            else:
+                one_instrumentor.instrument(tracer_provider=self.tracer_provider)

lite_bootstrap/instruments/__init__.py

@@ -0,0 +1,42 @@
+import dataclasses
+import typing
+
+import pydantic
+import sentry_sdk
+from sentry_sdk.integrations import Integration
+
+from lite_bootstrap.instruments.base import BaseInstrument
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class SentryInstrument(BaseInstrument):
+    dsn: str | None = None
+    sample_rate: float = pydantic.Field(default=1.0, le=1.0, ge=0.0)
+    traces_sample_rate: float | None = None
+    environment: str | None = None
+    max_breadcrumbs: int = 15
+    max_value_length: int = 16384
+    attach_stacktrace: bool = True
+    integrations: list[Integration] = dataclasses.field(default_factory=list)
+    additional_params: dict[str, typing.Any] = dataclasses.field(default_factory=dict)
+    tags: dict[str, str] | None = None
+
+    def is_ready(self) -> bool:
+        return bool(self.dsn)
+
+    def bootstrap(self) -> None:
+        sentry_sdk.init(
+            dsn=self.dsn,
+            sample_rate=self.sample_rate,
+            traces_sample_rate=self.traces_sample_rate,
+            environment=self.environment,
+            max_breadcrumbs=self.max_breadcrumbs,
+            max_value_length=self.max_value_length,
+            attach_stacktrace=self.attach_stacktrace,
+            integrations=self.integrations,
+            **self.additional_params,
+        )
+        tags: dict[str, str] = self.tags or {}
+        sentry_sdk.set_tags(tags)
+
+    def teardown(self) -> None: ...