bcl32-observability 0.1.0__tar.gz

bcl32_observability-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: bcl32-observability
+Version: 0.1.0
+Summary: Shared OpenTelemetry + structlog observability wiring for FastAPI services
+Project-URL: Repository, https://github.com/bcl32/python-modules
+Requires-Python: >=3.10
+Requires-Dist: structlog>=24.4.0
+Requires-Dist: opentelemetry-sdk>=1.27.0
+Requires-Dist: opentelemetry-exporter-otlp>=1.27.0
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100.0; extra == "fastapi"
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.48b0; extra == "fastapi"
+Requires-Dist: opentelemetry-instrumentation-sqlalchemy>=0.48b0; extra == "fastapi"
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.48b0; extra == "fastapi"
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"

bcl32_observability-0.1.0/README.md

@@ -0,0 +1,86 @@
+# bcl32-observability
+
+Shared OpenTelemetry + structlog observability wiring for FastAPI services in the monorepo.
+The Python reference implementation of [`OBSERVABILITY_CONTRACT.md`](../../OBSERVABILITY_CONTRACT.md):
+one call wires **metrics, logs, and traces** to the central Grafana Alloy collector (OTLP), which
+fans out to Prometheus / Loki / Tempo.
+
+## Installation
+
+```bash
+pip install bcl32-observability[fastapi]
+```
+
+The core install gives structlog + OTLP exporters + metric helpers. The `[fastapi]` extra adds the
+FastAPI / SQLAlchemy / httpx auto-instrumentation needed by `setup_observability`.
+
+## Usage
+
+```python
+from bcl32_observability import setup_observability, get_logger
+
+app = FastAPI(...)
+setup_observability(
+    app,
+    service_name="print-tracker-api",
+    service_version=APP_VERSION,
+    namespace="print-tracker",
+    environment="prod",
+    db_engine=db.engine,          # optional: SQLAlchemy (async) engine → DB spans
+)
+log = get_logger(__name__)
+log.info("startup.complete", category="app")
+```
+
+You get, with no further code: HTTP RED metrics + server spans, SQLAlchemy query spans, httpx client
+spans, and `trace_id`/`span_id` injected into every log line.
+
+### Domain metrics (OTel Meter)
+
+```python
+from bcl32_observability import make_counter
+
+PRINT_JOBS = make_counter("print_tracker_print_jobs_total", "Print jobs by status/source")
+PRINT_JOBS.add(1, {"status": "completed", "source": "archive"})
+```
+
+Labels (the `attributes` dict) must be **bounded** — never ids. See the contract §3.
+
+### Workers / cross-thread spans
+
+```python
+from bcl32_observability import capture_context, attached_context, get_tracer, bound_context
+
+ctx = capture_context()                       # on the producing thread (e.g. paho callback)
+...
+with attached_context(ctx):                   # on the consuming coroutine/thread
+    with get_tracer().start_as_current_span("mqtt.archive.process"):
+        with bound_context(archive_id=str(archive_id), category="mqtt"):
+            log.info("archive.processed")
+```
+
+## Configuration
+
+Entirely via standard `OTEL_*` env vars — no code changes to retarget:
+
+| Env var | Example |
+|---|---|
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://alloy:4317` |
+| `OTEL_RESOURCE_ATTRIBUTES` | `service.namespace=print-tracker,deployment.environment=prod` |
+| `OTEL_TRACES_SAMPLER` / `_ARG` | `parentbased_traceidratio` / `0.1` |
+
+## Publishing
+
+Published to PyPI by `.github/workflows/publish-observability.yml` on push to `main` that touches
+`observability/src/**` (or via manual `workflow_dispatch`). Version bump auto-detected from
+conventional commits; release tagged `observability-vX.Y.Z`.
+
+### Manual publish
+
+```bash
+cd python-modules/observability
+python3 -m venv .venv && source .venv/bin/activate
+pip install build twine
+python -m build
+twine upload dist/*
+```

bcl32_observability-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bcl32-observability"
+version = "0.1.0"
+description = "Shared OpenTelemetry + structlog observability wiring for FastAPI services"
+requires-python = ">=3.10"
+dependencies = [
+    "structlog>=24.4.0",
+    "opentelemetry-sdk>=1.27.0",
+    "opentelemetry-exporter-otlp>=1.27.0",
+]
+
+[project.optional-dependencies]
+# Framework auto-instrumentation. Kept out of the core so a non-FastAPI
+# consumer (or a core-only import) doesn't pull in FastAPI/SQLAlchemy/httpx.
+fastapi = [
+    "fastapi>=0.100.0",
+    "opentelemetry-instrumentation-fastapi>=0.48b0",
+    "opentelemetry-instrumentation-sqlalchemy>=0.48b0",
+    "opentelemetry-instrumentation-httpx>=0.48b0",
+]
+dev = ["build", "twine"]
+
+[project.urls]
+Repository = "https://github.com/bcl32/python-modules"
+
+[tool.setuptools.packages.find]
+where = ["src"]

bcl32_observability-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bcl32_observability-0.1.0/src/bcl32_observability/__init__.py

@@ -0,0 +1,41 @@
+"""
+bcl32-observability: shared OpenTelemetry + structlog wiring for the monorepo.
+
+Reference implementation of OBSERVABILITY_CONTRACT.md for Python/FastAPI services.
+One call wires metrics, logs, and traces:
+
+    from bcl32_observability import setup_observability, get_logger
+
+    setup_observability(app, service_name="print-tracker-api", service_version=APP_VERSION)
+    log = get_logger(__name__)
+
+Domain metrics:        make_counter / make_histogram / make_updown_counter / make_observable_gauge
+Worker correlation:    capture_context / attached_context / get_tracer  (cross-thread spans)
+Scoped log fields:     bound_context(**fields)
+"""
+
+from .context import attached_context, capture_context, get_tracer
+from .fastapi import setup_observability
+from .logging import bound_context, get_logger, setup_logging
+from .metrics import (
+    make_counter,
+    make_histogram,
+    make_observable_gauge,
+    make_updown_counter,
+)
+
+__all__ = [
+    "setup_observability",
+    "setup_logging",
+    "get_logger",
+    "bound_context",
+    "make_counter",
+    "make_histogram",
+    "make_updown_counter",
+    "make_observable_gauge",
+    "capture_context",
+    "attached_context",
+    "get_tracer",
+]
+
+__version__ = "0.1.0"

bcl32_observability-0.1.0/src/bcl32_observability/context.py

@@ -0,0 +1,47 @@
+"""
+Span + cross-thread context helpers (OBSERVABILITY_CONTRACT.md §5a).
+
+OpenTelemetry tracks the active span in a per-thread contextvar. It propagates
+automatically within one async flow and across HTTP (via `traceparent`), but NOT
+across a manual hand-off to another thread — a thread pool, a queue consumer, or
+the paho-MQTT → asyncio bridge. For those, capture the context on the producing
+side and re-attach it on the consuming side.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Any
+
+from opentelemetry import context as _otel_context
+from opentelemetry import trace
+
+
+def get_tracer(name: str = "bcl32_observability"):
+    return trace.get_tracer(name)
+
+
+def capture_context() -> Any:
+    """Snapshot the current OTel context. Call on the *producing* thread (e.g.
+    inside a paho callback) before handing work to another thread."""
+    return _otel_context.get_current()
+
+
+@contextmanager
+def attached_context(ctx: Any):
+    """Re-install a captured context for the duration of the block, then restore.
+
+    Use on the *consuming* side (e.g. the coroutine scheduled via
+    run_coroutine_threadsafe) so spans started inside parent correctly:
+
+        ctx = capture_context()              # producing thread
+        ...
+        with attached_context(ctx):          # consuming thread
+            with get_tracer().start_as_current_span("work"):
+                ...
+    """
+    token = _otel_context.attach(ctx)
+    try:
+        yield
+    finally:
+        _otel_context.detach(token)

bcl32_observability-0.1.0/src/bcl32_observability/fastapi.py

@@ -0,0 +1,52 @@
+"""
+The one-call adoption entry point for a FastAPI service.
+
+    from bcl32_observability import setup_observability, get_logger
+
+    setup_observability(app, service_name="print-tracker-api", service_version=APP_VERSION)
+    log = get_logger(__name__)
+
+It builds the Resource, installs the OTLP tracer/meter providers, configures
+structlog with trace-context injection, and auto-instruments FastAPI / httpx /
+(optionally) SQLAlchemy. Requires the `[fastapi]` extra.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .instrument import instrument_app
+from .logging import setup_logging
+from .resource import build_resource
+from .setup import init_telemetry
+
+
+def setup_observability(
+    app: Any,
+    *,
+    service_name: str,
+    service_version: str | None = None,
+    namespace: str | None = None,
+    environment: str | None = None,
+    db_engine: Any = None,
+    default_category: str = "app",
+) -> Any:
+    """Wire metrics, logs, and traces for a FastAPI app. Returns the app.
+
+    Args:
+        service_name: e.g. "print-tracker-api" (also via OTEL_SERVICE_NAME).
+        service_version: image tag / build version.
+        namespace: the project, e.g. "print-tracker".
+        environment: "dev" | "prod".
+        db_engine: optional SQLAlchemy (async) engine to instrument for DB spans.
+        default_category: structlog `category` default for this service.
+    """
+    resource = build_resource(service_name, service_version, namespace, environment)
+    init_telemetry(resource)
+    setup_logging(
+        service_name=service_name,
+        environment=environment,
+        default_category=default_category,
+    )
+    instrument_app(app, db_engine=db_engine)
+    return app

bcl32_observability-0.1.0/src/bcl32_observability/instrument.py

@@ -0,0 +1,50 @@
+"""
+Auto-instrumentation wiring (OBSERVABILITY_CONTRACT.md §3/§5).
+
+FastAPI instrumentation is the hard requirement (it's the point of the call), so a
+missing `[fastapi]` extra raises a clear error. httpx and SQLAlchemy are wired
+*best-effort* and independently: a service that makes no outbound httpx calls, or
+that passes no engine, simply isn't instrumented for those — it is never forced to
+install a library it doesn't use, and one instrumentor failing never blocks another.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+_log = logging.getLogger(__name__)
+
+
+def instrument_app(app: Any, *, db_engine: Any = None) -> None:
+    """Auto-instrument FastAPI (server spans + RED metrics) always; httpx (client
+    spans) if httpx is installed; SQLAlchemy (DB query spans) if an engine is given.
+
+    `db_engine` may be a sync Engine or an async engine (its `.sync_engine` is used).
+    """
+    try:
+        from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+    except ImportError as exc:
+        raise RuntimeError(
+            "setup_observability requires the [fastapi] extra: "
+            "pip install bcl32-observability[fastapi]"
+        ) from exc
+    FastAPIInstrumentor.instrument_app(app)
+
+    # httpx — only if the app actually has httpx available.
+    try:
+        from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
+
+        HTTPXClientInstrumentor().instrument()
+    except ImportError:
+        _log.debug("httpx not installed; skipping httpx instrumentation")
+
+    # SQLAlchemy — only when an engine is supplied.
+    if db_engine is not None:
+        try:
+            from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
+
+            sync_engine = getattr(db_engine, "sync_engine", db_engine)
+            SQLAlchemyInstrumentor().instrument(engine=sync_engine)
+        except ImportError:
+            _log.debug("sqlalchemy instrumentation unavailable; skipping")

bcl32_observability-0.1.0/src/bcl32_observability/logging.py

@@ -0,0 +1,121 @@
+"""
+Structured logging via structlog, wired for the observability contract (§4).
+
+Production gets JSON to stdout; an interactive TTY (or LOG_FORMAT=console) gets
+the dev-friendly console renderer. Stdlib loggers (uvicorn, asyncpg, and every
+`logging.getLogger(...)` caller) are routed through the same pipeline via
+ProcessorFormatter's foreign_pre_chain, so their lines pick up the same fields.
+
+On top of the canonical setup this adds two contract processors:
+  * trace-context injection — `trace_id` / `span_id` from the active OTel span,
+    the seam that joins logs to traces (§6).
+  * context defaults — `service`, `env`, and a default `category` so every line
+    is identifiable and filterable even when a call site omits them.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from contextlib import contextmanager
+from typing import Any
+
+import structlog
+from opentelemetry import trace
+
+
+def _trace_context(_logger: Any, _name: str, event_dict: dict) -> dict:
+    """Inject trace_id/span_id when emitted inside a recording span."""
+    span = trace.get_current_span()
+    ctx = span.get_span_context()
+    if ctx.is_valid:
+        event_dict["trace_id"] = format(ctx.trace_id, "032x")
+        event_dict["span_id"] = format(ctx.span_id, "016x")
+    return event_dict
+
+
+def _context_defaults(service_name: str, environment: str | None, default_category: str):
+    """Processor that fills identity fields without overriding explicit kwargs."""
+
+    def processor(_logger: Any, _name: str, event_dict: dict) -> dict:
+        event_dict.setdefault("service", service_name)
+        if environment:
+            event_dict.setdefault("env", environment)
+        event_dict.setdefault("category", default_category)
+        return event_dict
+
+    return processor
+
+
+def setup_logging(
+    *,
+    service_name: str,
+    environment: str | None = None,
+    default_category: str = "app",
+    level: int = logging.INFO,
+) -> None:
+    use_json = os.getenv(
+        "LOG_FORMAT",
+        "console" if sys.stderr.isatty() else "json",
+    ).lower() == "json"
+
+    shared_processors = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.add_logger_name,
+        # Copy LogRecord `extra={...}` attrs into the event_dict so foreign
+        # stdlib loggers surface their structured fields.
+        structlog.stdlib.ExtraAdder(),
+        _context_defaults(service_name, environment, default_category),
+        _trace_context,
+        structlog.processors.TimeStamper(fmt="iso"),
+    ]
+
+    structlog.configure(
+        processors=[
+            *shared_processors,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+    renderer = (
+        structlog.processors.JSONRenderer()
+        if use_json
+        else structlog.dev.ConsoleRenderer()
+    )
+    formatter = structlog.stdlib.ProcessorFormatter(
+        foreign_pre_chain=shared_processors,
+        processors=[
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            renderer,
+        ],
+    )
+
+    handler = logging.StreamHandler()
+    handler.setFormatter(formatter)
+    root = logging.getLogger()
+    root.handlers = [handler]
+    root.setLevel(level)
+
+    # Reduce noise from third-party loggers.
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+
+
+def get_logger(name: str | None = None):
+    """Return a structlog logger. Thin wrapper so apps stop importing structlog
+    directly and the processor chain can evolve centrally."""
+    return structlog.get_logger(name)
+
+
+@contextmanager
+def bound_context(**fields: Any):
+    """Bind structured fields onto every log line emitted within the block.
+
+    Use in workers / per-unit-of-work scopes (e.g. an MQTT archive handler) to
+    attach `archive_id`, `category`, etc. to all lines and their callees.
+    """
+    with structlog.contextvars.bound_contextvars(**fields):
+        yield

bcl32_observability-0.1.0/src/bcl32_observability/metrics.py

@@ -0,0 +1,64 @@
+"""
+Domain metric helpers over the OpenTelemetry Meter API (OBSERVABILITY_CONTRACT.md §3).
+
+Use these rather than raw `prometheus_client` so domain metrics ride the same
+OTLP pipeline and translate to Prometheus consistently. Naming convention:
+`<namespace>_<subject>_<unit>`, `_total` on counters, base units (`_seconds`,
+`_bytes`). Labels (passed as `attributes={...}` at record time) must be bounded —
+never inject ids / request-scoped values; those belong on spans or log fields.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Iterable, Sequence
+
+from opentelemetry import metrics as _metrics
+from opentelemetry.metrics import CallbackOptions, Counter, Histogram, Observation, UpDownCounter
+
+_METER_NAME = "bcl32_observability"
+
+
+def get_meter(name: str = _METER_NAME):
+    return _metrics.get_meter(name)
+
+
+def make_counter(name: str, description: str, unit: str = "1") -> Counter:
+    """Monotonic total, e.g. `print_tracker_print_jobs_total`."""
+    return get_meter().create_counter(name, unit=unit, description=description)
+
+
+def make_updown_counter(name: str, description: str, unit: str = "1") -> UpDownCounter:
+    """Value that rises and falls, e.g. queue depth / in-flight count."""
+    return get_meter().create_up_down_counter(name, unit=unit, description=description)
+
+
+def make_histogram(name: str, description: str, unit: str = "s") -> Histogram:
+    """Distribution, e.g. `print_tracker_slice_duration_seconds`."""
+    return get_meter().create_histogram(name, unit=unit, description=description)
+
+
+def make_observable_gauge(
+    name: str,
+    description: str,
+    callback: Callable[[CallbackOptions], Iterable[Observation]],
+    unit: str = "1",
+):
+    """Point-in-time value read on each collection via `callback`.
+
+    The callback returns an iterable of `Observation(value, {label: ...})`,
+    e.g. current pool size or aggregated inventory by material.
+    """
+    return get_meter().create_observable_gauge(
+        name, callbacks=[callback], unit=unit, description=description
+    )
+
+
+__all__: Sequence[str] = (
+    "get_meter",
+    "make_counter",
+    "make_updown_counter",
+    "make_histogram",
+    "make_observable_gauge",
+    "Observation",
+    "CallbackOptions",
+)

bcl32_observability-0.1.0/src/bcl32_observability/resource.py

@@ -0,0 +1,35 @@
+"""
+Build the OpenTelemetry Resource — the identity attached to every metric, log,
+and trace (see OBSERVABILITY_CONTRACT.md §2).
+
+`Resource.create()` already reads the standard `OTEL_SERVICE_NAME` and
+`OTEL_RESOURCE_ATTRIBUTES` env vars. We merge any explicit arguments *over* those
+env-derived defaults so a service can set its identity in code, in env, or both.
+"""
+
+from __future__ import annotations
+
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.semconv.resource import ResourceAttributes
+
+
+def build_resource(
+    service_name: str | None = None,
+    service_version: str | None = None,
+    namespace: str | None = None,
+    environment: str | None = None,
+) -> Resource:
+    """Resource from env (`OTEL_*`) with explicit args taking precedence."""
+    overrides: dict[str, str] = {}
+    if service_name:
+        overrides[ResourceAttributes.SERVICE_NAME] = service_name
+    if service_version:
+        overrides[ResourceAttributes.SERVICE_VERSION] = service_version
+    if namespace:
+        overrides[ResourceAttributes.SERVICE_NAMESPACE] = namespace
+    if environment:
+        overrides[ResourceAttributes.DEPLOYMENT_ENVIRONMENT] = environment
+
+    # Resource.create merges OTEL_RESOURCE_ATTRIBUTES / OTEL_SERVICE_NAME; the
+    # explicit dict wins on conflicts.
+    return Resource.create(overrides)

bcl32_observability-0.1.0/src/bcl32_observability/setup.py

@@ -0,0 +1,69 @@
+"""
+Initialise the OpenTelemetry tracer + meter providers and their OTLP exporters.
+
+Endpoint is read from `OTEL_EXPORTER_OTLP_ENDPOINT` by the exporters themselves
+(default `http://alloy:4317`); sampling from `OTEL_TRACES_SAMPLER[_ARG]`. The
+exporters are non-blocking and buffer in the background, so a collector outage
+never stalls a request (graceful degradation — see OBSERVABILITY_CONTRACT.md).
+"""
+
+from __future__ import annotations
+
+import os
+
+from opentelemetry import metrics, trace
+from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.sdk.trace.sampling import (
+    ALWAYS_OFF,
+    ALWAYS_ON,
+    ParentBased,
+    Sampler,
+    TraceIdRatioBased,
+)
+
+_initialised = False
+
+
+def _sampler_from_env() -> Sampler:
+    """Honour OTEL_TRACES_SAMPLER / OTEL_TRACES_SAMPLER_ARG.
+
+    Defaults to parent-based ratio sampling so trace volume is bounded from the
+    first deploy and upstream sampling decisions are respected.
+    """
+    name = os.getenv("OTEL_TRACES_SAMPLER", "parentbased_traceidratio").lower()
+    try:
+        ratio = float(os.getenv("OTEL_TRACES_SAMPLER_ARG", "1.0"))
+    except ValueError:
+        ratio = 1.0
+
+    if name in ("always_on", "parentbased_always_on"):
+        return ParentBased(ALWAYS_ON) if name.startswith("parent") else ALWAYS_ON
+    if name in ("always_off", "parentbased_always_off"):
+        return ParentBased(ALWAYS_OFF) if name.startswith("parent") else ALWAYS_OFF
+    if name == "traceidratio":
+        return TraceIdRatioBased(ratio)
+    # parentbased_traceidratio (default)
+    return ParentBased(TraceIdRatioBased(ratio))
+
+
+def init_telemetry(resource: Resource) -> None:
+    """Install global tracer + meter providers wired to OTLP. Idempotent."""
+    global _initialised
+    if _initialised:
+        return
+
+    tracer_provider = TracerProvider(resource=resource, sampler=_sampler_from_env())
+    tracer_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
+    trace.set_tracer_provider(tracer_provider)
+
+    reader = PeriodicExportingMetricReader(OTLPMetricExporter())
+    meter_provider = MeterProvider(resource=resource, metric_readers=[reader])
+    metrics.set_meter_provider(meter_provider)
+
+    _initialised = True

bcl32_observability-0.1.0/src/bcl32_observability.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: bcl32-observability
+Version: 0.1.0
+Summary: Shared OpenTelemetry + structlog observability wiring for FastAPI services
+Project-URL: Repository, https://github.com/bcl32/python-modules
+Requires-Python: >=3.10
+Requires-Dist: structlog>=24.4.0
+Requires-Dist: opentelemetry-sdk>=1.27.0
+Requires-Dist: opentelemetry-exporter-otlp>=1.27.0
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100.0; extra == "fastapi"
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.48b0; extra == "fastapi"
+Requires-Dist: opentelemetry-instrumentation-sqlalchemy>=0.48b0; extra == "fastapi"
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.48b0; extra == "fastapi"
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"

bcl32_observability-0.1.0/src/bcl32_observability.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/bcl32_observability/__init__.py
+src/bcl32_observability/context.py
+src/bcl32_observability/fastapi.py
+src/bcl32_observability/instrument.py
+src/bcl32_observability/logging.py
+src/bcl32_observability/metrics.py
+src/bcl32_observability/resource.py
+src/bcl32_observability/setup.py
+src/bcl32_observability.egg-info/PKG-INFO
+src/bcl32_observability.egg-info/SOURCES.txt
+src/bcl32_observability.egg-info/dependency_links.txt
+src/bcl32_observability.egg-info/requires.txt
+src/bcl32_observability.egg-info/top_level.txt

bcl32_observability-0.1.0/src/bcl32_observability.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bcl32_observability-0.1.0/src/bcl32_observability.egg-info/requires.txt

@@ -0,0 +1,13 @@
+structlog>=24.4.0
+opentelemetry-sdk>=1.27.0
+opentelemetry-exporter-otlp>=1.27.0
+
+[dev]
+build
+twine
+
+[fastapi]
+fastapi>=0.100.0
+opentelemetry-instrumentation-fastapi>=0.48b0
+opentelemetry-instrumentation-sqlalchemy>=0.48b0
+opentelemetry-instrumentation-httpx>=0.48b0

bcl32_observability-0.1.0/src/bcl32_observability.egg-info/top_level.txt

@@ -0,0 +1 @@
+bcl32_observability