Lite Bootstrap

https://github.com/modern-python/lite-bootstrap
Admin
Lite Bootstrap is a Python package that assists in creating microservices with pre-configured...
Tokens:28,299
Snippets:226
Trust Score:9
License:MIT
Update:4 weeks ago
Show doc for...
Tokens:
Raw
### Install lite-bootstrap[faststream-all] with uv, pip, or poetry

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/faststream.md

Install the lite-bootstrap[faststream-all] extra using uv, pip, or poetry. Choose the command that matches your package manager.

```bash
uv add lite-bootstrap[faststream-all]
```

```bash
pip install lite-bootstrap[faststream-all]
```

```bash
poetry add lite-bootstrap[faststream-all]
```

--------------------------------

### Install lite-bootstrap[free-all] with poetry

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/free.md

Use poetry to add the lite-bootstrap package with the free-all extra. This is the poetry tab of the installation step.

```bash
poetry add lite-bootstrap[free-all]
```

--------------------------------

### Install lite-bootstrap[fastapi-all] with uv, pip, or poetry

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/fastapi.md

Install the lite-bootstrap package with the fastapi-all extra using uv, pip, or poetry. Choose the command that matches your package manager.

```bash
uv add lite-bootstrap[fastapi-all]
```

```bash
pip install lite-bootstrap[fastapi-all]
```

```bash
poetry add lite-bootstrap[fastapi-all]
```

--------------------------------

### Install lite-bootstrap[fastmcp-all] with uv, pip, or poetry

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/fastmcp.md

Install the lite-bootstrap package with the fastmcp-all extra using uv, pip, or poetry. Choose the command that matches your package manager.

```bash
uv add lite-bootstrap[fastmcp-all]
```

```bash
pip install lite-bootstrap[fastmcp-all]
```

```bash
poetry add lite-bootstrap[fastmcp-all]
```

--------------------------------

### Install lite-bootstrap[free-all] with uv

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/free.md

Use uv to add the lite-bootstrap package with the free-all extra. This is the uv tab of the installation step.

```bash
uv add lite-bootstrap[free-all]
```

--------------------------------

### Install lite-bootstrap[free-all] with pip

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/free.md

Use pip to install the lite-bootstrap package with the free-all extra. This is the pip tab of the installation step.

```bash
pip install lite-bootstrap[free-all]
```

--------------------------------

### Install lite-bootstrap[litestar-all] with uv, pip, or poetry

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/litestar.md

Install the lite-bootstrap package with the litestar-all extra using uv, pip, or poetry. These are alternative package managers; choose the one that matches your project.

```bash
uv add lite-bootstrap[litestar-all]
```

```bash
pip install lite-bootstrap[litestar-all]
```

```bash
poetry add lite-bootstrap[litestar-all]
```

--------------------------------

### Install lite-bootstrap with pip

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/installation.md

Use pip to install lite-bootstrap with the litestar-logging and litestar-otl extras for structlog and opentelemetry support.

```bash
pip install lite-bootstrap[litestar-logging,litestar-otl]
```

--------------------------------

### Install lite-bootstrap with uv

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/installation.md

Use uv to add lite-bootstrap with the litestar-logging and litestar-otl extras for structlog and opentelemetry support.

```bash
uv add lite-bootstrap[litestar-logging,litestar-otl]
```

--------------------------------

### Install lite-bootstrap with poetry

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/installation.md

Use poetry to add lite-bootstrap with the litestar-logging and litestar-otl extras for structlog and opentelemetry support.

```bash
poetry add lite-bootstrap[litestar-logging,litestar-otl]
```

--------------------------------

### Build FastMCP application with FastMcpBootstrapper

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/fastmcp.md

Define a FastMcpConfig and build a FastMCP application using FastMcpBootstrapper. The example registers a simple tool named greet_person on the application.

```python
from fastmcp import FastMCP
from lite_bootstrap import FastMcpBootstrapper, FastMcpConfig


bootstrapper_config = FastMcpConfig(
    service_name="microservice",
    service_version="2.0.0",
    service_environment="test",
    sentry_dsn="https://testdsn@localhost/1",
    prometheus_metrics_path="/custom-metrics/",
    health_checks_path="/custom-health/",
    logging_buffer_capacity=0,
)
bootstrapper = FastMcpBootstrapper(bootstrap_config=bootstrapper_config)
application: FastMCP = bootstrapper.bootstrap()


@application.tool
def greet_person(person_name: str) -> str:
    return f"Hello, {person_name}!"
```

--------------------------------

### Define FreeBootstrapperConfig and bootstrap

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/free.md

Creates a FreeBootstrapperConfig with an OpenTelemetry endpoint and Sentry DSN, then instantiates FreeBootstrapper and calls bootstrap(). This is the second step of the usage example.

```python
from lite_bootstrap import FreeBootstrapperConfig, FreeBootstrapper


bootstrapper_config = FreeBootstrapperConfig(
    opentelemetry_endpoint="otl",
    sentry_dsn="https://testdsn@localhost/1",
)
bootstrapper = FreeBootstrapper(bootstrapper_config)
bootstrapper.bootstrap()
```

--------------------------------

### Configure OpenTelemetry sampler with ParentBased and TraceIdRatioBased

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/configuration.md

Sets up a sampling strategy that records only 1% of traces using ParentBased(TraceIdRatioBased(0.01)). This reduces tracing costs significantly; the example notes it saved ~55 µs per request on a benchmark endpoint compared to the always-on default.

```python
from opentelemetry.sdk.trace.sampling import ParentBased, TraceIdRatioBased

config = FastAPIConfig(
    service_name="my-service",
    opentelemetry_endpoint="otl",
    opentelemetry_sampler=ParentBased(TraceIdRatioBased(0.01)),
)
```

--------------------------------

### Tuned FastAPI configuration for Sentry and OpenTelemetry

Source: https://github.com/modern-python/lite-bootstrap/blob/main/benchmarks/README.md

Use this configuration to let OpenTelemetry own distributed tracing while Sentry acts as an error sink. It disables HTTP method capture for Sentry integrations, disables Sentry log breadcrumbs and auto session tracking, excludes 'receive' and 'send' spans from OpenTelemetry, and applies a 1% trace sampler. This setup saves ~32 µs/req by skipping Transaction creation and costs nothing for Sentry Logs while disabled.

```python
FastAPIConfig(
    # Sentry: OTel owns distributed tracing, Sentry is an error sink
    sentry_integrations=[
        StarletteIntegration(http_methods_to_capture=()),
        FastApiIntegration(http_methods_to_capture=()),
    ],
    sentry_logging_breadcrumb_level=None,
    sentry_auto_tracking=False,
    # OpenTelemetry: sampling is the single biggest saving here
    opentelemetry_exclude_spans=["receive", "send"],
    opentelemetry_sampler=ParentBased(TraceIdRatioBased(0.01)),
)
```

--------------------------------

### Get issue database id

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Fetches the numeric database id of an issue, not the #number or node_id.

```bash
gh api repos/<owner>/<repo>/issues/<n> --jq .id
```

--------------------------------

### Bootstrap a FastAPI app with FastAPIBootstrapper

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/quickstart.md

Create main.py with a FastAPIConfig and FastAPIBootstrapper. bootstrap() returns a ready FastAPI app with every configured instrument attached.

```python
from fastapi import FastAPI
from lite_bootstrap import FastAPIConfig, FastAPIBootstrapper

config = FastAPIConfig(
    service_name="my-service",
    service_version="1.0.0",
    service_environment="local",
    prometheus_metrics_path="/metrics",
    health_checks_enabled=True,
    health_checks_path="/health",
    cors_allowed_origins=["*"],
    swagger_offline_docs=True,
)

app: FastAPI = FastAPIBootstrapper(config).bootstrap()


@app.get("/")
async def root() -> dict[str, str]:
    return {"hello": "world"}
```

--------------------------------

### Build FastStream application with FastStreamBootstrapper

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/faststream.md

Define a FastStreamConfig with Redis broker, OpenTelemetry, Prometheus, Sentry, health checks, and logging settings, then build the application with FastStreamBootstrapper. The bootstrap() call returns the ASGI application.

```python
from lite_bootstrap import FastStreamConfig, FastStreamBootstrapper
from faststream.asgi import AsgiFastStream
from faststream.redis.opentelemetry import RedisTelemetryMiddleware
from faststream.redis.prometheus import RedisPrometheusMiddleware
from faststream.redis import RedisBroker


broker = RedisBroker()
bootstrapper_config = FastStreamConfig(
    service_name="microservice",
    service_version="2.0.0",
    service_environment="test",
    opentelemetry_endpoint="otl",
    opentelemetry_middleware_cls=RedisTelemetryMiddleware,
    prometheus_metrics_path="/custom-metrics/",
    prometheus_middleware_cls=RedisPrometheusMiddleware,
    sentry_dsn="https://testdsn@localhost/1",
    health_checks_path="/custom-health/",
    logging_buffer_capacity=0,
    application=AsgiFastStream(broker),
)
bootstrapper = FastStreamBootstrapper(bootstrapper_config)
application = bootstrapper.bootstrap()
```

--------------------------------

### Enable more instruments with FastAPIConfig

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/quickstart.md

Enable additional instruments by adding their config fields. Unset or empty fields are skipped automatically, so you only pay for what you enable.

```python
config = FastAPIConfig(
    service_name="my-service",
    service_version="1.0.0",
    service_environment="local",
    # tracing — spans exported to your OTLP endpoint
    opentelemetry_endpoint="http://localhost:4317",
    # error reporting
    sentry_dsn="https://examplePublicKey@o0.ingest.sentry.io/0",
    # continuous profiling (needs the `pyroscope` extra)
    pyroscope_endpoint="http://localhost:4040",
)
```

--------------------------------

### Run benchmark scenarios with run.py

Source: https://github.com/modern-python/lite-bootstrap/blob/main/benchmarks/README.md

Runs the benchmark scenarios for stack, Sentry, OpenTelemetry, and HTTP using the project's virtual environment. Each command re-invokes sys.executable per scenario because patching cannot be undone in-process.

```bash
cd benchmarks

# per-instrument breakdown and the tuned stack (section 4)
../.venv/bin/python run.py stack async bare,log,prom,sentry,otel,full,full_all_tuned

# the two OpenTelemetry knobs (section 4a)
../.venv/bin/python run.py stack async otel,otel_exclude_spans,otel_sampler,otel_tuned

# the Sentry ablation, where every familiar knob turns out to be a no-op (section 4b)
../.venv/bin/python run.py sentry async off,errors_only,errors_only_lean,errors_only_no_integrations,errors_only_no_txn

# cost per log record (section 4c)
../.venv/bin/python run.py sentry logging off,errors_only,errors_only_no_sentry_logs,errors_only_logging_lean

# the headline numbers, over real sockets - needs `ab` on PATH
../.venv/bin/python run_http.py stack async bare,full,full_all_tuned

# what a scenario gives up, and where the time goes inside one
../.venv/bin/python verify.py errors_only errors_only_no_txn errors_only_logging_lean errors_only_skip_txn
../.venv/bin/python micro.py
../.venv/bin/python profile_one.py sentry errors_only
../.venv/bin/python profile_one.py sentry errors_only --callers 'Random.seed'
```

--------------------------------

### Configure and bootstrap FastAPI with FastAPIConfig and FastAPIBootstrapper

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/fastapi.md

Define a FastAPIConfig with service metadata, CORS origins, custom health and metrics paths, OpenTelemetry endpoint, Sentry DSN, and offline Swagger docs. Then create a FastAPIBootstrapper and call bootstrap() to build the FastAPI application.

```python
from lite_bootstrap import FastAPIConfig, FastAPIBootstrapper


bootstrapper_config = FastAPIConfig(
    service_name="microservice",
    service_version="2.0.0",
    service_environment="test",
    cors_allowed_origins=["http://test"],
    health_checks_path="/custom-health/",
    opentelemetry_endpoint="otl",
    prometheus_metrics_path="/custom-metrics/",
    sentry_dsn="https://testdsn@localhost/1",
    swagger_offline_docs=True,
)
bootstrapper = FastAPIBootstrapper(bootstrapper_config)
application = bootstrapper.bootstrap()
```

--------------------------------

### Configure and bootstrap a Litestar application with lite-bootstrap

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/litestar.md

Define a LitestarConfig with service metadata, CORS, health checks, OpenTelemetry, Prometheus, Sentry, and offline Swagger, then build the application with LitestarBootstrapper.bootstrap().

```python
from lite_bootstrap import LitestarConfig, LitestarBootstrapper


bootstrapper_config = LitestarConfig(
    service_name="microservice",
    service_version="2.0.0",
    service_environment="test",
    cors_allowed_origins=["http://test"],
    health_checks_path="/custom-health/",
    opentelemetry_endpoint="otl",
    prometheus_metrics_path="/custom-metrics/",
    sentry_dsn="https://testdsn@localhost/1",
    swagger_offline_docs=True,
)
bootstrapper = LitestarBootstrapper(bootstrapper_config)
application = bootstrapper.bootstrap()
```

--------------------------------

### Inspect enabled and skipped instruments

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/quickstart.md

Inspect which instruments were enabled or skipped at startup using build_summary() and skipped_instruments.

```python
bootstrapper = FastAPIBootstrapper(config)
app = bootstrapper.bootstrap()

print(bootstrapper.build_summary())  # human-readable summary
for cls, reason in bootstrapper.skipped_instruments:
    print(f"skipped {cls.__name__}: {reason}")
```

--------------------------------

### Run the FastAPI service with uvicorn

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/quickstart.md

Run the FastAPI service with uvicorn, enabling auto-reload for development.

```bash
uvicorn main:app --reload
```

--------------------------------

### Configure FastAPI with OpenTelemetry endpoints

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/configuration.md

Creates a FastAPIConfig with OpenTelemetry tracing and metrics endpoints. Use this when you need to enable both traces and metrics for a service. The endpoints point to a local OTLP collector.

```python
config = FastAPIConfig(
    service_name="my-service",
    opentelemetry_endpoint="localhost:4317",
    opentelemetry_metrics_endpoint="localhost:4317",
)
```

--------------------------------

### Set request_max_body_size with AppConfig

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/litestar.md

Set a custom request_max_body_size via your own AppConfig. The bootstrapper fills in Litestar's 10 MB default only when unset; any value you set (including None for no limit) is left untouched.

```python
from litestar.config.app import AppConfig

LitestarConfig(
    service_name="microservice",
    application_config=AppConfig(request_max_body_size=5_000_000),  # 5 MB limit
)
```

--------------------------------

### Enable FastMCP logging middleware in FastMcpConfig

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/fastmcp.md

Enable the per-MCP-message access log by setting fastmcp_logging_middleware_enabled to True. The log is off by default; when enabled, each message is logged with method, source, type, and duration in nanoseconds.

```python
FastMcpConfig(
    service_name="microservice",
    fastmcp_logging_middleware_enabled=True,
)
```

--------------------------------

### Resolve an issue with comment and close

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Comments an answer on an issue, then closes it, and appends a context pointer to the map's Decisions-so-far.

```bash
gh issue comment <n> --body "<answer>"
```

```bash
gh issue close <n>
```

--------------------------------

### Show a pull request diff

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Shows the diff for a pull request.

```bash
gh pr diff <number>
```

--------------------------------

### Inspect skipped instruments programmatically

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/configuration.md

Use this to iterate over bootstrapper.skipped_instruments, which contains tuples of the instrument class and its not_configured_reason. This is useful for debugging or logging which instruments were skipped and why.

```python
bootstrapper = FastAPIBootstrapper(bootstrap_config=config)
for cls, reason in bootstrapper.skipped_instruments:
    print(f"{cls.__name__}: {reason}")
```

--------------------------------

### Create a wayfinder map issue

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Creates a new issue with the wayfinder:map label.

```bash
gh issue create --label wayfinder:map
```

--------------------------------

### List open issues with JSON

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Lists open issues with selected fields and a jq filter for number, title, body, labels, and comments.

```bash
gh issue list --state open --json number,title,body,labels,comments --jq '[.[] | {number, title, body, labels: [.labels[].name], comments: [.comments[].body]}]'
```

--------------------------------

### Enable FastAPI logging middleware with fastapi_logging_middleware_enabled

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/fastapi.md

Enable the FastAPI logging middleware by setting fastapi_logging_middleware_enabled to True. It is off by default because uvicorn already writes an access log. When enabled, it logs one http_request line per request to the http.access logger with method, path, content_type, path_params, status_code, and duration. Request and response bodies are never logged, but path and path_params are, so secrets in the URL are recorded.

```python
FastAPIConfig(
    service_name="microservice",
    fastapi_logging_middleware_enabled=True,
)
```

--------------------------------

### Enable Litestar logging middleware with metadata-only logging

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/litestar.md

Enable Litestar's LoggingMiddleware explicitly. It is off by default because its defaults log full request/response bodies, which can expose credentials and the offline Swagger bundle. When enabled this way, it logs only metadata and skips swagger, health, and metrics paths.

```python
LitestarConfig(
    service_name="microservice",
    litestar_logging_middleware_enabled=True,
)
```

--------------------------------

### Customize Litestar logging middleware with LoggingMiddlewareConfig

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/litestar.md

Pass a custom LoggingMiddlewareConfig to take full control. This replaces the defaults entirely, including path exclusions. A bare LoggingMiddlewareConfig() restores Litestar's own defaults, including full body logging, so pass explicit request_log_fields/response_log_fields.

```python
from litestar.middleware.logging import LoggingMiddlewareConfig

LitestarConfig(
    service_name="microservice",
    litestar_logging_middleware_enabled=True,
    litestar_logging_middleware_config=LoggingMiddlewareConfig(request_log_fields=("path", "method", "content_type")),
)
```

--------------------------------

### Add a blocking dependency via API

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Adds a native issue dependency using the GitHub API, using the blocker's database id.

```bash
gh api --method POST repos/<owner>/<repo>/issues/<child>/dependencies/blocked_by -F issue_id=<blocker-db-id>
```

--------------------------------

### Create an issue with gh

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Creates a new GitHub issue with a title and body. Use a heredoc for multi-line bodies.

```bash
gh issue create --title "..." --body "..."
```

--------------------------------

### Claim an issue

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Assigns the current user to an issue, the session's first write.

```bash
gh issue edit <n> --add-assignee @me
```

--------------------------------

### Configure structlog timestamp format with TimeStamper

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/configuration.md

Shows how to pass a custom structlog.processors.TimeStamper instance to the logging_time_stamper parameter of FastAPIConfig to change the timestamp format and enable UTC. The default is TimeStamper(fmt="iso").

```python
import structlog
from lite_bootstrap import FastAPIConfig

config = FastAPIConfig(
    logging_time_stamper=structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S", utc=True),
)
```

--------------------------------

### Close an issue with comment

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Closes an issue with an optional comment.

```bash
gh issue close <number> --comment "..."
```

--------------------------------

### Read a pull request with comments

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Reads a pull request with its comments.

```bash
gh pr view <number> --comments
```

--------------------------------

### Read an issue with comments

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Reads an issue with its comments, filtering by jq and fetching labels.

```bash
gh issue view <number> --comments
```

--------------------------------

### Set FastStream broker log level independently

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/configuration.md

Shows how to keep application logs at INFO while suppressing broker service messages to WARNING using faststream_log_level. The broker log level is independent from the application log level.

```python
import logging
from lite_bootstrap import FastStreamConfig

config = FastStreamConfig(
    logging_log_level=logging.INFO,  # your application logs
    faststream_log_level=logging.WARNING,  # broker "Received"/"Processed" messages (default)
)
```

--------------------------------

### Attach a logging filter to demote expected errors

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/configuration.md

Shows how to use logging_record_filters to attach a logging.Filter to a named logger. The filter rewrites the record's level for expected errors and returns True to keep it. Remember to set both levelno and levelname, and note that logger names are exact matches.

```python
import logging

from lite_bootstrap import FreeBootstrapper, FreeConfig


class ExpectedFailureFilter(logging.Filter):
    def filter(self, record: logging.LogRecord) -> bool:
        if record.levelno == logging.ERROR and "expected failure" in record.getMessage():
            record.levelno = logging.WARNING
            record.levelname = "WARNING"
        return True


bootstrapper = FreeBootstrapper(
    bootstrap_config=FreeConfig(
        logging_record_filters={"some_library.worker": (ExpectedFailureFilter(),)},
    ),
)
```

--------------------------------

### List external PRs for triage

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Lists open pull requests with fields for triage, including author association.

```bash
gh pr list --state open --json number,title,body,labels,author,authorAssociation,comments
```

--------------------------------

### Disable Prometheus path grouping and add additional params

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/litestar.md

Set prometheus_group_path=False to record raw paths instead of route templates. Anything in prometheus_additional_params (including group_path) overrides the default. The default True bounds metric cardinality; without it, parameterized routes mint a new series per distinct value.

```python
LitestarConfig(
    service_name="microservice",
    prometheus_group_path=False,  # raw paths
    prometheus_additional_params={"exclude_unhandled_paths": True},
)
```

--------------------------------

### Disable uvicorn access log with logging_unset_handlers

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/fastapi.md

Enable the FastAPI logging middleware and clear uvicorn's access log handlers to avoid duplicate log lines. Use logging_unset_handlers with ["uvicorn.access"] to leave only the structured http_request log.

```python
FastAPIConfig(
    service_name="microservice",
    fastapi_logging_middleware_enabled=True,
    logging_unset_handlers=["uvicorn.access"],
)
```

--------------------------------

### Comment on an issue

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Adds a comment to an existing issue.

```bash
gh issue comment <number> --body "..."
```

--------------------------------

### Log with request.logger in a Litestar route handler

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/integrations/litestar.md

Use request.logger in a route handler, provided by StructlogPlugin integration. This logs the message 'listing items' when the /items endpoint is called.

```python
from litestar import Request, get


@get("/items")
async def list_items(request: Request) -> list[str]:
    request.logger.info("listing items")
    return []
```

--------------------------------

### Add a label to an issue

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Adds a label to an issue using gh issue edit.

```bash
gh issue edit <number> --add-label "..."
```

--------------------------------

### Filter InstrumentDependencyMissingWarning

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/introduction/configuration.md

Use this to suppress the InstrumentDependencyMissingWarning warning, which is emitted when an instrument is configured but its optional dependency is missing. This is a UserWarning subclass, so it can be filtered with warnings.filterwarnings.

```python
import warnings
from lite_bootstrap import InstrumentDependencyMissingWarning

warnings.filterwarnings("ignore", category=InstrumentDependencyMissingWarning)
```

--------------------------------

### Remove a label from an issue

Source: https://github.com/modern-python/lite-bootstrap/blob/main/docs/agents/issue-tracker.md

Removes a label from an issue using gh issue edit.

```bash
gh issue edit <number> --remove-label "..."
```
Tokens:
Raw