ko-observability 0.2.0__py3-none-any.whl

ko_observability/__init__.py

@@ -0,0 +1,15 @@
+"""Nexora org-wide OpenTelemetry libraries."""
+
+from ko_observability.client import get_meter, get_tracer
+from ko_observability.otel import init_otel
+from ko_observability.structlog_bridge import make_otel_bridge, otel_bridge
+
+__all__ = [
+    "init_otel",
+    "get_tracer",
+    "get_meter",
+    "otel_bridge",
+    "make_otel_bridge",
+]
+
+__version__ = "0.2.0"

ko_observability/client.py

@@ -0,0 +1,67 @@
+"""Lazy OTel client helpers for library and application code.
+
+Use these when you want a Tracer/Meter without requiring the host process to
+have called ``init_otel`` first (e.g. inside a reusable library). Each
+function bootstraps a minimal provider on first use if -- and only if -- no
+provider has been registered yet by the host process.
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+
+from opentelemetry import metrics as _otel_metrics
+from opentelemetry import trace
+
+from ko_observability.exporters import make_span_exporter
+from ko_observability.otlp_config import sdk_disabled
+
+_init_lock = threading.Lock()
+_initialized = False
+
+
+def get_tracer(name: str, version: str | None = None):
+    """Return a Tracer, lazily bootstrapping a minimal provider if needed."""
+    _ensure_trace_provider()
+    return trace.get_tracer(name, version)
+
+
+def get_meter(name: str, version: str | None = None) -> _otel_metrics.Meter:
+    """Return a Meter (no-op if metrics provider is not configured)."""
+    return _otel_metrics.get_meter(name, version or "")
+
+
+def _ensure_trace_provider() -> None:
+    global _initialized
+    if _initialized:
+        return
+    with _init_lock:
+        if _initialized:
+            return
+        if sdk_disabled():
+            _initialized = True
+            return
+
+        provider = trace.get_tracer_provider()
+        if "NoOp" not in type(provider).__name__ and "Proxy" not in type(provider).__name__:
+            _initialized = True
+            return
+
+        try:
+            from opentelemetry.sdk.resources import Resource
+            from opentelemetry.sdk.trace import TracerProvider
+            from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+            resource = Resource.create(
+                {
+                    "service.name": os.getenv("OTEL_SERVICE_NAME", "nexora-service"),
+                    "service.namespace": os.getenv("OTEL_SERVICE_NAMESPACE", "nexora"),
+                }
+            )
+            tp = TracerProvider(resource=resource)
+            tp.add_span_processor(BatchSpanProcessor(make_span_exporter()))
+            trace.set_tracer_provider(tp)
+        except Exception:
+            pass
+        _initialized = True

ko_observability/exporters.py

@@ -0,0 +1,208 @@
+"""Exporter factories: local JSONL files (default) or OTLP/gRPC, per TELEMETRY_DESTINATION.
+
+File exporters write one OTLP/JSON ``Export*ServiceRequest`` per line -- the
+same encoding the Collector's ``otlpjsonfile`` receiver replays -- with
+``traceId``/``spanId``/``parentSpanId`` rewritten from protobuf-JSON base64
+to the spec's hex form. Append-only, one ``write()`` per batch, mutex-guarded.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import json
+import logging
+import os
+import threading
+from collections.abc import Sequence
+from typing import Any
+
+from opentelemetry.sdk._logs.export import LogRecordExporter, LogRecordExportResult
+from opentelemetry.sdk.metrics.export import MetricExporter, MetricExportResult, MetricsData
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+from ko_observability.otlp_config import (
+    otlp_endpoint,
+    otlp_exporter_insecure,
+    telemetry_destination,
+    telemetry_file_dir,
+)
+
+_logger = logging.getLogger(__name__)
+
+TRACES_FILE = "traces.jsonl"
+METRICS_FILE = "metrics.jsonl"
+LOGS_FILE = "logs.jsonl"
+
+_ID_KEYS = frozenset({"traceId", "spanId", "parentSpanId"})
+
+
+def _b64_to_hex(value: str) -> str:
+    try:
+        return base64.b64decode(value, validate=True).hex()
+    except (binascii.Error, ValueError):
+        return value
+
+
+def _hex_ids(obj: Any) -> Any:
+    if isinstance(obj, dict):
+        return {
+            k: (_b64_to_hex(v) if k in _ID_KEYS and isinstance(v, str) else _hex_ids(v))
+            for k, v in obj.items()
+        }
+    if isinstance(obj, list):
+        return [_hex_ids(v) for v in obj]
+    return obj
+
+
+def _to_otlp_json(message: Any) -> dict[str, Any]:
+    from google.protobuf.json_format import MessageToDict
+
+    return _hex_ids(MessageToDict(message, use_integers_for_enums=True))
+
+
+class _JsonlWriter:
+    def __init__(self, path: str) -> None:
+        os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+        self._fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+        self._lock = threading.Lock()
+
+    def write_line(self, obj: dict[str, Any]) -> None:
+        data = (json.dumps(obj, separators=(",", ":")) + "\n").encode("utf-8")
+        with self._lock:
+            if self._fd < 0:
+                raise OSError("telemetry file closed")
+            view = memoryview(data)
+            written = 0
+            try:
+                while view:
+                    n = os.write(self._fd, view)
+                    written += n
+                    view = view[n:]
+            except OSError:
+                # A partial write before the failure leaves a fragment (no
+                # trailing newline) on disk -- but only if this call made any
+                # progress at all; a failure on the very first byte leaves the
+                # file exactly as the last successful write_line left it (already
+                # newline-terminated), so no recovery byte is needed there.
+                # Left alone, the next successful export would append onto the
+                # fragment and produce one unparseable JSONL line, corrupting
+                # previously-good data rather than just the failed batch.
+                # Best-effort: terminate the fragment with a newline so line
+                # framing survives, then propagate the original error (never
+                # crash the host).
+                if written > 0:
+                    try:
+                        os.write(self._fd, b"\n")
+                    except OSError:
+                        pass
+                raise
+
+    def close(self) -> None:
+        with self._lock:
+            if self._fd >= 0:
+                os.close(self._fd)
+                self._fd = -1
+
+
+def _default_path(name: str) -> str:
+    return os.path.join(telemetry_file_dir(), name)
+
+
+class FileSpanExporter(SpanExporter):
+    def __init__(self, path: str | None = None) -> None:
+        self._writer = _JsonlWriter(path or _default_path(TRACES_FILE))
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        try:
+            from opentelemetry.exporter.otlp.proto.common.trace_encoder import encode_spans
+
+            self._writer.write_line(_to_otlp_json(encode_spans(spans)))
+            return SpanExportResult.SUCCESS
+        except Exception as exc:
+            _logger.warning("telemetry.file_export_failed: traces: %s", exc)
+            return SpanExportResult.FAILURE
+
+    def shutdown(self) -> None:
+        self._writer.close()
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return True
+
+
+class FileLogExporter(LogRecordExporter):
+    def __init__(self, path: str | None = None) -> None:
+        self._writer = _JsonlWriter(path or _default_path(LOGS_FILE))
+
+    def export(self, batch: Sequence[Any]) -> LogRecordExportResult:
+        try:
+            from opentelemetry.exporter.otlp.proto.common._log_encoder import encode_logs
+
+            self._writer.write_line(_to_otlp_json(encode_logs(batch)))
+            return LogRecordExportResult.SUCCESS
+        except Exception as exc:
+            _logger.warning("telemetry.file_export_failed: logs: %s", exc)
+            return LogRecordExportResult.FAILURE
+
+    def shutdown(self) -> None:
+        self._writer.close()
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return True
+
+
+class FileMetricExporter(MetricExporter):
+    def __init__(
+        self,
+        path: str | None = None,
+        preferred_temporality: dict[type, Any] | None = None,
+        preferred_aggregation: dict[type, Any] | None = None,
+    ) -> None:
+        super().__init__(
+            preferred_temporality=preferred_temporality,
+            preferred_aggregation=preferred_aggregation,
+        )
+        self._writer = _JsonlWriter(path or _default_path(METRICS_FILE))
+
+    def export(
+        self, metrics_data: MetricsData, timeout_millis: float = 10_000, **kwargs: Any
+    ) -> MetricExportResult:
+        try:
+            from opentelemetry.exporter.otlp.proto.common.metrics_encoder import encode_metrics
+
+            self._writer.write_line(_to_otlp_json(encode_metrics(metrics_data)))
+            return MetricExportResult.SUCCESS
+        except Exception as exc:
+            _logger.warning("telemetry.file_export_failed: metrics: %s", exc)
+            return MetricExportResult.FAILURE
+
+    def force_flush(self, timeout_millis: float = 10_000) -> bool:
+        return True
+
+    def shutdown(self, timeout_millis: float = 30_000, **kwargs: Any) -> None:
+        self._writer.close()
+
+
+def make_span_exporter() -> SpanExporter:
+    if telemetry_destination() == "file":
+        return FileSpanExporter()
+    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+
+    return OTLPSpanExporter(endpoint=otlp_endpoint(), insecure=otlp_exporter_insecure())
+
+
+def make_log_exporter() -> LogRecordExporter:
+    if telemetry_destination() == "file":
+        return FileLogExporter()
+    from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
+
+    return OTLPLogExporter(endpoint=otlp_endpoint(), insecure=otlp_exporter_insecure())
+
+
+def make_metric_exporter() -> MetricExporter:
+    if telemetry_destination() == "file":
+        return FileMetricExporter()
+    from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
+
+    return OTLPMetricExporter(endpoint=otlp_endpoint(), insecure=otlp_exporter_insecure())

ko_observability/otel.py

@@ -0,0 +1,262 @@
+"""OpenTelemetry bootstrap for Nexora services.
+
+Single public entry point: ``init_otel``. Reads standard OTEL_* env vars,
+builds a Resource, configures exporters (local JSONL files by default,
+OTLP/gRPC when TELEMETRY_DESTINATION=otlp), and registers global providers.
+Optionally attaches FastAPI middleware. Idempotent. No-ops if
+OTEL_SDK_DISABLED=true.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import os
+import threading
+from collections.abc import Sequence
+from typing import Any
+
+from opentelemetry.context import Context
+from opentelemetry.sdk.trace import Span, SpanProcessor
+
+from ko_observability.exporters import (
+    make_log_exporter,
+    make_metric_exporter,
+    make_span_exporter,
+)
+from ko_observability.otlp_config import sdk_disabled
+
+_logger = logging.getLogger(__name__)
+
+_init_lock = threading.Lock()
+_initialized: bool = False
+_current_service_name: str | None = None
+
+
+def get_current_service_name() -> str | None:
+    """Return the ``service_name`` passed to ``init_otel``, or ``None`` if
+    it hasn't been called yet in this process. Used by ``query.py`` to
+    self-scope read access to the calling service's own telemetry without
+    requiring the caller to repeat the service name."""
+    return _current_service_name
+
+
+class StructlogContextSpanProcessor(SpanProcessor):
+    """Stamp span attributes from structlog contextvars.
+
+    ``attr_map`` is a sequence of ``(contextvar_key, span_attribute_key)``
+    pairs copied from ``structlog.contextvars.get_contextvars()`` onto every
+    new span. Empty by default -- pass your app's own correlation keys, e.g.
+    ``(("request_id", "http.request_id"),)``.
+    """
+
+    def __init__(self, attr_map: Sequence[tuple[str, str]] = ()) -> None:
+        self._attr_map = tuple(attr_map)
+
+    def on_start(self, span: Span, parent_context: Context | None = None) -> None:
+        if not self._attr_map:
+            return
+        try:
+            from structlog.contextvars import get_contextvars
+
+            ctx = get_contextvars()
+            for ctx_key, attr_key in self._attr_map:
+                if ctx_key not in ctx:
+                    continue
+                value = ctx[ctx_key]
+                if value is not None:
+                    span.set_attribute(attr_key, str(value))
+        except Exception:
+            pass
+
+    def on_end(self, span) -> None:
+        return
+
+    def shutdown(self) -> None:
+        return
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return True
+
+
+def init_otel(
+    service_name: str,
+    service_namespace: str = "nexora",
+    instrument_fastapi_app: Any | None = None,
+    enable_logs: bool = True,
+    enable_metrics: bool = True,
+    extra_metric_readers: Sequence[Any] | None = None,
+    span_processors: Sequence[SpanProcessor] | None = None,
+    context_attr_map: Sequence[tuple[str, str]] = (),
+) -> None:
+    """Initialize OpenTelemetry for this process.
+
+    Args:
+        service_name: Resource ``service.name``.
+        service_namespace: Resource ``service.namespace`` (shared org label).
+        instrument_fastapi_app: Optional FastAPI app for HTTP auto-instrumentation.
+        enable_logs: Register OTLP log export when LOG_DESTINATION is otlp/both.
+        enable_metrics: Register OTLP metric export.
+        extra_metric_readers: Additional metric readers (e.g. in-memory admin reader).
+        span_processors: Processors registered before the batch exporter (after
+            the default StructlogContextSpanProcessor).
+        context_attr_map: ``(contextvar_key, span_attribute_key)`` pairs stamped
+            onto every span from structlog contextvars, e.g.
+            ``(("request_id", "http.request_id"),)``. Empty by default.
+    """
+    global _initialized, _current_service_name
+    with _init_lock:
+        if _initialized:
+            if instrument_fastapi_app is not None:
+                _try_instrument_fastapi(instrument_fastapi_app)
+            return
+
+        # Recorded on this first (and only effective) call, even down the
+        # disabled/exception paths below -- get_current_service_name()
+        # reflects "what service_name was this process configured with",
+        # independent of whether export actually succeeded.
+        _current_service_name = service_name
+
+        if sdk_disabled():
+            from opentelemetry import trace
+            from opentelemetry.trace import NoOpTracerProvider
+
+            trace.set_tracer_provider(NoOpTracerProvider())
+            _initialized = True
+            return
+
+        try:
+            from opentelemetry import trace
+            from opentelemetry.sdk.resources import Resource
+            from opentelemetry.sdk.trace import TracerProvider
+            from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+            resource_attrs = {
+                "service.name": service_name,
+                "service.namespace": service_namespace,
+                "service.version": os.getenv("SERVICE_VERSION", "0.0.0"),
+                "deployment.environment": os.getenv("DEPLOYMENT_ENV", "development"),
+            }
+            resource = Resource.create(resource_attrs)
+            provider = TracerProvider(resource=resource)
+
+            provider.add_span_processor(StructlogContextSpanProcessor(context_attr_map))
+            if span_processors:
+                for proc in span_processors:
+                    provider.add_span_processor(proc)
+
+            provider.add_span_processor(BatchSpanProcessor(make_span_exporter()))
+
+            trace.set_tracer_provider(provider)
+
+            log_destination = os.getenv("LOG_DESTINATION", "stdout").strip().lower()
+            if enable_logs and log_destination in ("otlp", "both"):
+                _init_logs(resource)
+
+            if enable_metrics:
+                _init_metrics(resource, extra_metric_readers)
+
+            _try_instrument_httpx()
+            _try_instrument_elasticsearch()
+            if instrument_fastapi_app is not None:
+                _try_instrument_fastapi(instrument_fastapi_app)
+
+            _initialized = True
+        except Exception as exc:
+            _logger.warning("otel.init_failed: %s", exc)
+            _initialized = True
+
+
+def _init_logs(resource: Any) -> None:
+    from opentelemetry._logs import set_logger_provider
+    from opentelemetry.sdk._logs import LoggerProvider
+    from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+
+    log_provider = LoggerProvider(resource=resource)
+    log_provider.add_log_record_processor(BatchLogRecordProcessor(make_log_exporter()))
+    set_logger_provider(log_provider)
+
+
+def _metric_export_interval_ms() -> int:
+    """Parse ``OTEL_METRIC_EXPORT_INTERVAL``, falling back to 60000 ms.
+
+    The env var is used iff it parses as a finite number greater than zero;
+    anything else (unset, non-numeric, negative, zero, NaN/Infinity) silently
+    falls back to the default. Matches the JS/Go SDKs' behavior.
+    """
+    raw = os.getenv("OTEL_METRIC_EXPORT_INTERVAL", "")
+    try:
+        value = float(raw)
+    except (TypeError, ValueError):
+        return 60000
+    if not math.isfinite(value) or value <= 0:
+        return 60000
+    return int(value)
+
+
+def _init_metrics(resource: Any, extra_metric_readers: Sequence[Any] | None) -> None:
+    from opentelemetry import metrics as otel_metrics
+    from opentelemetry.sdk.metrics import MeterProvider
+    from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+
+    readers: list[Any] = [
+        PeriodicExportingMetricReader(
+            exporter=make_metric_exporter(),
+            export_interval_millis=_metric_export_interval_ms(),
+        )
+    ]
+    if extra_metric_readers:
+        readers.extend(extra_metric_readers)
+
+    provider = MeterProvider(resource=resource, metric_readers=readers)
+    otel_metrics.set_meter_provider(provider)
+
+
+def _try_instrument_httpx() -> None:
+    try:
+        from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
+
+        HTTPXClientInstrumentor().instrument()
+    except Exception:
+        pass
+
+
+def _try_instrument_elasticsearch() -> None:
+    try:
+        from opentelemetry.instrumentation.elasticsearch import (
+            ElasticsearchInstrumentor,
+        )
+
+        ElasticsearchInstrumentor().instrument()
+    except Exception:
+        pass
+
+
+def _fastapi_server_request_hook(span: Any, scope: dict) -> None:
+    """Rename the span to ``METHOD /matched/route/template`` when a route
+    actually matched. Deliberately does NOT fall back to the raw request
+    path for unmatched routes (404s, health-check probes hitting unknown
+    paths, etc.) -- that would let unbounded, attacker-controlled path
+    segments become span names/cardinality. Unmatched requests keep
+    FastAPIInstrumentor's default span name."""
+    try:
+        if span is None or not span.is_recording():
+            return
+        route = scope.get("route", None)
+        path = getattr(route, "path", None)
+        if not path:
+            return
+        method = scope.get("method", "")
+        if method:
+            span.update_name(f"{method} {path}")
+    except Exception:
+        pass
+
+
+def _try_instrument_fastapi(app: Any) -> None:
+    try:
+        from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+
+        FastAPIInstrumentor.instrument_app(app, server_request_hook=_fastapi_server_request_hook)
+    except Exception:
+        pass

ko_observability/otlp_config.py

@@ -0,0 +1,88 @@
+"""OTLP exporter settings shared by trace, log, and metric exporters."""
+
+from __future__ import annotations
+
+import logging
+import os
+
+_logger = logging.getLogger(__name__)
+
+
+def parse_bool_env(raw: str) -> bool | None:
+    """Boolean-ish env parsing shared across the Python/JS/Go SDKs.
+
+    Trims whitespace, lowercases, then compares. Truthy: ``true``, ``1``,
+    ``yes``. Falsy: ``false``, ``0``, ``no``. Anything else (including an
+    empty/unset value) is "not specified" -- returns ``None`` so the caller
+    can apply its own default.
+    """
+    value = raw.strip().lower()
+    if value in ("true", "1", "yes"):
+        return True
+    if value in ("false", "0", "no"):
+        return False
+    return None
+
+
+def sdk_disabled() -> bool:
+    """Whether ``OTEL_SDK_DISABLED`` is truthy (see ``parse_bool_env``)."""
+    return parse_bool_env(os.getenv("OTEL_SDK_DISABLED", "")) is True
+
+
+def otlp_endpoint() -> str:
+    """OTLP/gRPC endpoint (standard ``OTEL_EXPORTER_OTLP_ENDPOINT``).
+
+    Set-but-empty or whitespace-only (e.g. a compose file's
+    ``OTEL_EXPORTER_OTLP_ENDPOINT=`` line) is treated the same as unset,
+    matching the JS (``||``) and Go (``if v != ""``) SDKs.
+    """
+    return os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT", "").strip() or "http://localhost:4317"
+
+
+def otlp_exporter_insecure() -> bool:
+    """Whether OTLP gRPC exporters should use an insecure channel.
+
+    Honors ``OTEL_EXPORTER_OTLP_INSECURE`` when set (explicit truthy ->
+    plaintext, explicit falsy -> TLS, even when the endpoint is
+    ``http://`` -- passing a concrete bool to the exporter constructors
+    overrides their own scheme inference). Otherwise infers from the
+    endpoint scheme: ``http://`` -> insecure, ``https://`` -> TLS.
+    """
+    flag = parse_bool_env(os.getenv("OTEL_EXPORTER_OTLP_INSECURE", ""))
+    if flag is not None:
+        return flag
+    return otlp_endpoint().startswith("http://")
+
+
+_TELEMETRY_DESTINATIONS = ("file", "otlp")
+_warned_invalid_destination = False
+
+
+def telemetry_destination() -> str:
+    """Where exporters send: ``"file"`` (default) or ``"otlp"``.
+
+    ``TELEMETRY_DESTINATION`` is trimmed and lowercased. Unset/empty -> ``file``.
+    Anything unrecognized -> ``file`` plus one ``telemetry.destination_invalid``
+    warning per process. Identical parsing in the JS/Go SDKs.
+    """
+    global _warned_invalid_destination
+    raw = os.getenv("TELEMETRY_DESTINATION", "")
+    value = raw.strip().lower()
+    if value == "":
+        return "file"
+    if value in _TELEMETRY_DESTINATIONS:
+        return value
+    if not _warned_invalid_destination:
+        _warned_invalid_destination = True
+        _logger.warning("telemetry.destination_invalid: %r (using 'file')", raw)
+    return "file"
+
+
+def telemetry_file_dir() -> str:
+    """Directory for ``traces.jsonl``/``metrics.jsonl``/``logs.jsonl`` in file mode.
+
+    ``TELEMETRY_FILE_DIR`` trimmed; unset/blank -> ``./telemetry`` (relative to
+    the process CWD; no ``~`` expansion, matching JS/Go).
+    """
+    value = os.getenv("TELEMETRY_FILE_DIR", "").strip()
+    return value or "./telemetry"

ko_observability/query.py

@@ -0,0 +1,436 @@
+"""Read-only query helpers for admin-panel style access to logs/traces/
+metrics this service already emitted via ``init_otel``. Optional -- requires
+the ``query`` extra (``pip install ko-observability[query]``); nothing
+else in this package imports this module, so producer services that only
+emit telemetry never pull in its dependency (``httpx``).
+
+Deliberately **not** backend-agnostic. OpenTelemetry's own ecosystem
+convention keeps write (SDK) and read (backend-native tooling: Kibana,
+Grafana, a vendor's own API) separate on purpose -- different backends have
+fundamentally different query shapes, and a genuine abstraction over
+"any backend" ends up either thin-and-leaky or a full reimplementation of
+what those tools already do. This is a thin, Elasticsearch-specific helper
+matching the ``mapping.mode: otel`` field layout the gateway Collector
+writes to (see ``docs/otel.md``'s Architecture section). If a second
+backend is ever actually added, build its own client rather than forcing
+one interface over both.
+
+Security model: every method defaults to scoping results to the *calling
+process's own* ``service_name`` (read from ``init_otel``'s
+``get_current_service_name()``, or the ``OTEL_SERVICE_NAME`` env var as a
+fallback) -- so one app's admin panel can't casually see another app's
+telemetry through this helper alone. This is a **library-layer**
+convenience, not a security boundary: the Elasticsearch credentials this
+reads with should themselves be scoped server-side (a per-service API key
+with document-level security restricting to that service's
+``resource.attributes.service.name``) before exposing this to anything less
+trusted than the app's own operators. See ``docs/query.md``.
+
+Field-path note: ES field mappings here (``@timestamp``, ``trace_id``,
+``span_id``, ``parent_span_id``, ``severity_text``, ``body.text``,
+``status.code``, ``resource.attributes.*``, ``attributes.*``,
+``metrics.<dotted.name>``) are verified against a live cluster by the e2e
+suite (``e2e/test_query.py``, ``e2e/test_traces.py``, ``e2e/test_metrics.py``):
+all filter fields are keyword (exact ``term``), ``status.code`` is OTel
+title-case (``"Error"``, not ``"ERROR"``), ``body.text`` is analyzed
+(``match``), and ``metrics.<dotted.name>`` is indexed as a literal dotted
+key -- ``_extract_metric_value``'s nested-object branch is a defensive
+fallback for an alternate mapping shape, not the one actually observed.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any
+from urllib.parse import urlsplit, urlunsplit
+
+import httpx
+
+from ko_observability.otel import get_current_service_name
+
+TRACES_INDEX = "traces-generic.otel-default"
+LOGS_INDEX = "logs-generic.otel-default"
+METRICS_INDEX = "metrics-generic.otel-default"
+
+_DEFAULT_ES_URL = "https://localhost:9200"
+
+
+@dataclass
+class LogEntry:
+    timestamp: str
+    severity: str | None
+    body: str
+    trace_id: str | None
+    span_id: str | None
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class TraceSummary:
+    trace_id: str
+    span_id: str
+    name: str
+    duration_ms: float | None
+    status: str | None
+    start_time: str
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class Span:
+    span_id: str
+    parent_span_id: str | None
+    trace_id: str
+    name: str
+    duration_ms: float | None
+    status: str | None
+    start_time: str
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class MetricPoint:
+    timestamp: str
+    value: float
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ExecutionResult:
+    """Combined result for ``get_execution`` -- everything correlated to one
+    custom attribute value (e.g. a task/job execution id) across both the
+    traces and logs indices."""
+
+    execution_id: str
+    traces: list[TraceSummary]
+    logs: list[LogEntry]
+
+
+class QueryClientError(RuntimeError):
+    """Raised for ES connection/auth failures or missing service_name."""
+
+
+def _resolve_since(since: str) -> str:
+    """Accepts either an ES date-math expression (``"now-1h"``, passed
+    through unchanged) or a bare duration shorthand (``"1h"``, ``"15m"``,
+    ``"2d"``) which gets ``now-`` prepended."""
+    return since if since.startswith("now") else f"now-{since}"
+
+
+def _attribute_filters(attributes: dict[str, str] | None) -> list[dict[str, Any]]:
+    if not attributes:
+        return []
+    return [{"term": {f"attributes.{key}": value}} for key, value in attributes.items()]
+
+
+def _redact_url(url: str) -> str:
+    """Strip any userinfo (``user:pass@``) from a URL before it's allowed
+    into an exception message. ``ELASTICSEARCH_URL``/``es_url`` may carry
+    embedded basic-auth credentials (httpx picks those up automatically for
+    the actual request) -- those must never leak into a raised error."""
+    parts = urlsplit(url)
+    if "@" not in (parts.netloc or ""):
+        return url
+    netloc = parts.netloc.rsplit("@", 1)[-1]
+    return urlunsplit((parts.scheme, netloc, parts.path, parts.query, parts.fragment))
+
+
+class QueryClient:
+    """Thin Elasticsearch query client scoped to one service's telemetry.
+
+    Prefer ``get_query_client()`` over constructing this directly -- it
+    resolves ``service_name`` and connection settings from the same
+    environment ``init_otel`` already uses.
+    """
+
+    def __init__(
+        self,
+        service_name: str,
+        *,
+        es_url: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        api_key: str | None = None,
+        ca_certs: str | None = None,
+        timeout: float = 10.0,
+    ) -> None:
+        self.service_name = service_name
+        self._es_url = (es_url or os.getenv("ELASTICSEARCH_URL") or _DEFAULT_ES_URL).rstrip("/")
+        # Redacted once up front -- this is the only form of the ES URL that
+        # may ever reach an exception message (self._es_url itself may carry
+        # embedded basic-auth credentials; see _redact_url).
+        self._es_url_display = _redact_url(self._es_url)
+
+        headers: dict[str, str] = {}
+        auth: tuple[str, str] | None = None
+        resolved_api_key = api_key or os.getenv("ELASTICSEARCH_API_KEY")
+        if resolved_api_key:
+            headers["Authorization"] = f"ApiKey {resolved_api_key}"
+        else:
+            resolved_username = (
+                username if username is not None else os.getenv("ELASTICSEARCH_USERNAME", "elastic")
+            )
+            resolved_password = (
+                password
+                or os.getenv("ELASTICSEARCH_PASSWORD")
+                or os.getenv("ELASTIC_PASSWORD")  # base-stack env var name
+            )
+            if resolved_password:
+                auth = (resolved_username, resolved_password)
+
+        verify: str | bool = ca_certs or os.getenv("ELASTICSEARCH_CA_CERTS") or True
+
+        self._client = httpx.Client(
+            base_url=self._es_url,
+            headers=headers,
+            auth=auth,
+            verify=verify,
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> QueryClient:
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+    def _search(
+        self,
+        index: str,
+        query: dict[str, Any],
+        *,
+        sort: list[dict[str, Any]],
+        size: int,
+    ) -> list[dict[str, Any]]:
+        try:
+            response = self._client.post(
+                f"/{index}/_search",
+                json={"query": query, "sort": sort, "size": size},
+            )
+        except httpx.HTTPError as exc:
+            raise QueryClientError(
+                f"failed to reach Elasticsearch at {self._es_url_display}: {exc}"
+            ) from exc
+
+        if response.status_code == 404:
+            # Data stream not created yet (no documents written) -- not an error.
+            return []
+        if response.is_error:
+            raise QueryClientError(
+                f"Elasticsearch query against '{index}' failed "
+                f"({response.status_code}): {response.text}"
+            )
+        return [hit["_source"] for hit in response.json()["hits"]["hits"]]
+
+    def list_logs(
+        self,
+        since: str = "1h",
+        *,
+        level: str | None = None,
+        search_text: str | None = None,
+        attributes: dict[str, str] | None = None,
+        limit: int = 100,
+    ) -> list[LogEntry]:
+        filters: list[dict[str, Any]] = [
+            {"term": {"resource.attributes.service.name": self.service_name}},
+            {"range": {"@timestamp": {"gte": _resolve_since(since)}}},
+            *_attribute_filters(attributes),
+        ]
+        if level:
+            # Under the OTel index mapping severity_text is a keyword; a term
+            # query hits it directly. OTel severity_text is already upper-case
+            # (INFO/WARN/ERROR/...).
+            filters.append({"term": {"severity_text": level.upper()}})
+
+        must: list[dict[str, Any]] = []
+        if search_text:
+            must.append({"match": {"body.text": search_text}})
+
+        docs = self._search(
+            LOGS_INDEX,
+            {"bool": {"filter": filters, "must": must}},
+            sort=[{"@timestamp": "desc"}],
+            size=limit,
+        )
+        return [
+            LogEntry(
+                timestamp=doc.get("@timestamp", ""),
+                severity=doc.get("severity_text"),
+                body=doc.get("body", {}).get("text", ""),
+                trace_id=doc.get("trace_id"),
+                span_id=doc.get("span_id"),
+                attributes=doc.get("attributes", {}),
+            )
+            for doc in docs
+        ]
+
+    def list_traces(
+        self,
+        since: str = "1h",
+        *,
+        status: str | None = None,
+        attributes: dict[str, str] | None = None,
+        limit: int = 50,
+    ) -> list[TraceSummary]:
+        filters: list[dict[str, Any]] = [
+            {"term": {"resource.attributes.service.name": self.service_name}},
+            {"range": {"@timestamp": {"gte": _resolve_since(since)}}},
+            *_attribute_filters(attributes),
+        ]
+        must_not: list[dict[str, Any]] = [{"exists": {"field": "parent_span_id"}}]
+        if status:
+            # Under the OTel index mapping status.code is a keyword, hit
+            # directly by term. Its serialized value is OTel title-case
+            # ("Error"/"Ok"/"Unset"), NOT upper-case. str.capitalize() maps
+            # error->Error, ok->Ok, unset->Unset.
+            filters.append({"term": {"status.code": status.capitalize()}})
+
+        docs = self._search(
+            TRACES_INDEX,
+            {"bool": {"filter": filters, "must_not": must_not}},
+            sort=[{"@timestamp": "desc"}],
+            size=limit,
+        )
+        return [_trace_summary_from_doc(doc) for doc in docs]
+
+    def get_trace(self, trace_id: str, *, limit: int = 1000) -> list[Span]:
+        """All spans for ``trace_id``, scoped -- like every other method on
+        this client -- to this client's own ``service_name``. Consequence:
+        spans contributed to the same distributed trace by *other* services
+        are not returned by this call; querying the full cross-service trace
+        requires calling ``get_trace`` against each contributing service's
+        own QueryClient.
+        """
+        docs = self._search(
+            TRACES_INDEX,
+            {
+                "bool": {
+                    "filter": [
+                        {"term": {"trace_id": trace_id}},
+                        {"term": {"resource.attributes.service.name": self.service_name}},
+                    ]
+                }
+            },
+            sort=[{"@timestamp": "asc"}],
+            size=limit,
+        )
+        return [
+            Span(
+                span_id=doc.get("span_id", ""),
+                parent_span_id=doc.get("parent_span_id"),
+                trace_id=doc.get("trace_id", trace_id),
+                name=doc.get("name", ""),
+                duration_ms=_duration_ms(doc),
+                status=doc.get("status", {}).get("code") if doc.get("status") else None,
+                start_time=doc.get("@timestamp", ""),
+                attributes=doc.get("attributes", {}),
+            )
+            for doc in docs
+        ]
+
+    def get_metric(
+        self, metric_name: str, since: str = "1h", *, limit: int = 500
+    ) -> list[MetricPoint]:
+        filters = [
+            {"term": {"resource.attributes.service.name": self.service_name}},
+            {"range": {"@timestamp": {"gte": _resolve_since(since)}}},
+            {"exists": {"field": f"metrics.{metric_name}"}},
+        ]
+        docs = self._search(
+            METRICS_INDEX,
+            {"bool": {"filter": filters}},
+            sort=[{"@timestamp": "asc"}],
+            size=limit,
+        )
+        points = []
+        for doc in docs:
+            value = _extract_metric_value(doc.get("metrics", {}), metric_name)
+            if value is None:
+                continue
+            points.append(
+                MetricPoint(
+                    timestamp=doc.get("@timestamp", ""),
+                    value=value,
+                    attributes=doc.get("attributes", {}),
+                )
+            )
+        return points
+
+    def get_execution(
+        self,
+        execution_id: str,
+        *,
+        attr_key: str = "execution_id",
+        since: str = "7d",
+        limit: int = 200,
+    ) -> ExecutionResult:
+        """Everything correlated to one custom attribute value (a task/job
+        execution id, a request id, whatever an app chose to stamp) --
+        across both traces and logs, in one call. Requires the app to have
+        stamped that attribute itself: pass it via ``init_otel``'s
+        ``context_attr_map`` (for spans) and ``make_otel_bridge``'s
+        ``correlation_keys`` (for logs) at startup -- see
+        ``docs/onboarding-a-new-module.md``.
+        """
+        attrs = {attr_key: execution_id}
+        return ExecutionResult(
+            execution_id=execution_id,
+            traces=self.list_traces(since=since, attributes=attrs, limit=limit),
+            logs=self.list_logs(since=since, attributes=attrs, limit=limit),
+        )
+
+
+def _trace_summary_from_doc(doc: dict[str, Any]) -> TraceSummary:
+    status = doc.get("status", {})
+    return TraceSummary(
+        trace_id=doc.get("trace_id", ""),
+        span_id=doc.get("span_id", ""),
+        name=doc.get("name", ""),
+        duration_ms=_duration_ms(doc),
+        status=status.get("code") if status else None,
+        start_time=doc.get("@timestamp", ""),
+        attributes=doc.get("attributes", {}),
+    )
+
+
+def _duration_ms(doc: dict[str, Any]) -> float | None:
+    # `duration` in the ES otel mapping is nanoseconds; e2e/test_traces.py
+    # confirms the field exists but not its unit -- adjust the divisor here
+    # if a live run shows otherwise.
+    duration_ns = doc.get("duration")
+    return duration_ns / 1_000_000 if duration_ns is not None else None
+
+
+def _extract_metric_value(metrics_obj: dict[str, Any], dotted_name: str) -> float | None:
+    """`metrics.<name>` may be indexed as a literal dotted key or as nested
+    objects matching the name's dot segments, depending on the ES mapping.
+    Try both."""
+    if dotted_name in metrics_obj:
+        value = metrics_obj[dotted_name]
+        return value if isinstance(value, (int, float)) else None
+    node: Any = metrics_obj
+    for part in dotted_name.split("."):
+        if not isinstance(node, dict) or part not in node:
+            return None
+        node = node[part]
+    return node if isinstance(node, (int, float)) else None
+
+
+def get_query_client(service_name: str | None = None, **kwargs: Any) -> QueryClient:
+    """Return a QueryClient scoped to ``service_name``, falling back to the
+    current process's own service (from ``init_otel``, or the
+    ``OTEL_SERVICE_NAME`` env var). Raises QueryClientError if neither is
+    available -- pass ``service_name`` explicitly or call ``init_otel``
+    first.
+    """
+    resolved = service_name or get_current_service_name() or os.getenv("OTEL_SERVICE_NAME")
+    if not resolved:
+        raise QueryClientError(
+            "no service_name available: pass one explicitly, call init_otel() first, "
+            "or set OTEL_SERVICE_NAME"
+        )
+    return QueryClient(resolved, **kwargs)

ko_observability/structlog_bridge.py

@@ -0,0 +1,115 @@
+"""Structlog -> OpenTelemetry log bridge."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from opentelemetry import trace
+from opentelemetry._logs import LogRecord, SeverityNumber, get_logger_provider
+
+_LEVEL_TO_SEVERITY: dict[str, SeverityNumber] = {
+    "debug": SeverityNumber.DEBUG,
+    "info": SeverityNumber.INFO,
+    "warning": SeverityNumber.WARN,
+    "warn": SeverityNumber.WARN,
+    "error": SeverityNumber.ERROR,
+    "critical": SeverityNumber.FATAL,
+}
+
+
+def _get_provider_or_none():
+    """Return the registered LoggerProvider, or ``None`` if none is configured.
+
+    ``get_logger_provider()`` defaults to a ``ProxyLoggerProvider`` (not a
+    ``NoOpLoggerProvider``) when nothing has been registered yet, so both must
+    be treated as "unconfigured" -- matches the class-name check in
+    ``client.py``'s ``_ensure_trace_provider``.
+    """
+    provider = get_logger_provider()
+    if provider is None or type(provider).__name__ in ("NoOpLoggerProvider", "ProxyLoggerProvider"):
+        return None
+    return provider
+
+
+def make_otel_bridge(
+    correlation_keys: frozenset[str] = frozenset(),
+    attribute_prefix: str = "",
+    logger_name: str = "ko_observability.structlog",
+):
+    """Build a structlog processor that emits one OTel LogRecord per event.
+
+    Args:
+        correlation_keys: event_dict keys namespaced under ``attribute_prefix``
+            on the emitted LogRecord (e.g. ``{"request_id", "run_id"}``).
+            Every other key is passed through unprefixed as a LogRecord
+            attribute -- except ``event``, ``level``, ``timestamp``, and
+            ``@timestamp``, which are always dropped from ``attributes``
+            because they're already carried by the LogRecord's own
+            ``body``/``severity_text``/``timestamp`` fields. Empty by
+            default.
+        attribute_prefix: prefix applied to ``correlation_keys`` attributes,
+            e.g. ``"myapp."``. Ignored if ``correlation_keys`` is empty.
+        logger_name: name registered with the OTel LoggerProvider.
+
+    Returns a structlog processor with signature
+    ``(logger, method_name, event_dict) -> event_dict``. Never raises --
+    any failure building or emitting the LogRecord is swallowed and the
+    event_dict is passed through unchanged, so a bridge bug can't break the
+    app's logging.
+    """
+
+    def _build_attributes(event_dict: dict[str, Any]) -> dict[str, Any]:
+        attributes: dict[str, Any] = {}
+        for key, value in event_dict.items():
+            if key in ("event", "level", "timestamp", "@timestamp"):
+                continue
+            if key in correlation_keys:
+                attributes[f"{attribute_prefix}{key}"] = value
+            else:
+                attributes[key] = value
+        return attributes
+
+    def _otel_bridge(_logger, _method_name, event_dict: dict[str, Any]) -> dict[str, Any]:
+        # Never break the app's logging: any failure here (a bad provider,
+        # an unexpected event_dict shape, an exporter-side error surfacing
+        # through emit()) is swallowed and the event still reaches
+        # structlog's other processors/renderer unchanged.
+        try:
+            provider = _get_provider_or_none()
+            if provider is None:
+                return event_dict
+
+            span = trace.get_current_span()
+            ctx = span.get_span_context() if span is not None else None
+            trace_id = ctx.trace_id if ctx and ctx.is_valid else 0
+            span_id = ctx.span_id if ctx and ctx.is_valid else 0
+            trace_flags = ctx.trace_flags if ctx and ctx.is_valid else None
+
+            level = str(event_dict.get("level", "info")).lower()
+            severity = _LEVEL_TO_SEVERITY.get(level, SeverityNumber.INFO)
+            body = event_dict.get("event", "")
+
+            now_ns = time.time_ns()
+            record = LogRecord(
+                timestamp=now_ns,
+                observed_timestamp=now_ns,
+                trace_id=trace_id,
+                span_id=span_id,
+                trace_flags=trace_flags,
+                severity_text=level.upper(),
+                severity_number=severity,
+                body=body,
+                attributes=_build_attributes(event_dict),
+            )
+
+            otel_logger = provider.get_logger(logger_name)
+            otel_logger.emit(record)
+        except Exception:
+            pass
+        return event_dict
+
+    return _otel_bridge
+
+
+otel_bridge = make_otel_bridge()

ko_observability-0.2.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.5
+Name: ko-observability
+Version: 0.2.0
+Summary: Org-wide OpenTelemetry bootstrap for Nexora Python services
+Project-URL: Repository, https://github.com/Komus-ai/nexora-observability
+Project-URL: Documentation, https://github.com/Komus-ai/nexora-observability/tree/main/docs
+Author-email: Komus-ai <dev@cinco.ai>
+License: MIT
+Keywords: observability,opentelemetry,otlp,structlog
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.12
+Requires-Dist: opentelemetry-api>=1.27.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-common>=1.27.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.27.0
+Requires-Dist: opentelemetry-sdk>=1.27.0
+Requires-Dist: protobuf<8.0,>=5.0
+Requires-Dist: structlog>=24.4.0
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27.0; extra == 'dev'
+Requires-Dist: mypy>=1.13.0; extra == 'dev'
+Requires-Dist: opentelemetry-sdk>=1.27.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Provides-Extra: elasticsearch
+Requires-Dist: opentelemetry-instrumentation-elasticsearch>=0.48b0; extra == 'elasticsearch'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.115.0; extra == 'fastapi'
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.48b0; extra == 'fastapi'
+Provides-Extra: httpx
+Requires-Dist: opentelemetry-instrumentation-httpx>=0.48b0; extra == 'httpx'
+Provides-Extra: query
+Requires-Dist: httpx>=0.27.0; extra == 'query'
+Description-Content-Type: text/markdown
+
+# ko-observability (Python)
+
+Org-wide OpenTelemetry bootstrap for Nexora Python services: one-call, idempotent
+`init_otel` for process startup, lazy `get_tracer` / `get_meter` accessors for library code
+that doesn't own process lifecycle, and a structlog processor (`otel_bridge` /
+`make_otel_bridge`) that stamps each log line with the active span's `trace_id`/`span_id`.
+
+## Install
+
+```bash
+pip install ko-observability
+```
+
+Optional extras, install alongside the base package as needed:
+
+```bash
+# Auto-instrument FastAPI request/response spans
+pip install "ko-observability[fastapi]"
+
+# Auto-instrument outbound httpx calls
+pip install "ko-observability[httpx]"
+
+# Auto-instrument the Elasticsearch client
+pip install "ko-observability[elasticsearch]"
+
+# Read your own service's telemetry back out (admin-panel style queries)
+pip install "ko-observability[query]"
+```
+
+## Quick start
+
+```python
+from ko_observability import init_otel, get_tracer
+
+init_otel(service_name="my-service", service_namespace="nexora")
+
+tracer = get_tracer(__name__)
+with tracer.start_as_current_span("do-work"):
+    ...
+```
+
+Call `init_otel` exactly once at process startup. It's safe to call again (or to let library
+code fall back to `get_tracer`/`get_meter` before it runs) — both paths are no-ops on top of an
+already-configured provider. `OTEL_SDK_DISABLED=true` turns the whole thing into a no-op, and a
+misconfigured exporter degrades to "telemetry doesn't work" rather than crashing the host process.
+
+### Where does it go?
+
+| `TELEMETRY_DESTINATION` | Output |
+|---|---|
+| `file` (default) | `$TELEMETRY_FILE_DIR/{traces,metrics,logs}.jsonl` (default `./telemetry`), one OTLP/JSON request per line |
+| `otlp` | OTLP/gRPC to `OTEL_EXPORTER_OTLP_ENDPOINT` (default `http://localhost:4317`) |
+
+Full contract: [docs/otel.md → Local file mode](../../docs/otel.md#local-file-mode-the-default).
+
+## Reading telemetry back (`query` extra)
+
+```python
+from ko_observability.query import get_query_client
+
+client = get_query_client()
+traces = client.list_traces(limit=20)
+```
+
+Scoped to the caller's own `service_name` by default. See [`docs/query.md`](../../docs/query.md).
+
+## Docs
+
+Full documentation — env vars, the logs/metrics pipelines, semantic conventions, and the
+Collector deployment this SDK ships telemetry to — lives in the repository:
+
+https://github.com/Komus-ai/nexora-observability/tree/main/docs

ko_observability-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+ko_observability/__init__.py,sha256=NEE95_51mzhAltbETsHCPfmcKIGs72ZBxJgduxDpeWM,359
+ko_observability/client.py,sha256=xGu2TBeXyMgeQ2XGsw6nyfGAG_UBkowUduXIAP2gRQI,2224
+ko_observability/exporters.py,sha256=EW2lEaDwc5foMzxWjOLSQzEXQavldKfQiGNrtvj6I5M,7489
+ko_observability/otel.py,sha256=6hcA0-NnD-dQNFeiHHB0RoULBvCdCQ2jYETCToEVaHs,9409
+ko_observability/otlp_config.py,sha256=Y2XNdHNOdiFklJajjhHuTOkRjzXgpX60hXvp24BfwJM,3093
+ko_observability/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ko_observability/query.py,sha256=jK7C65WP7HRKSwqgjdbdBLP5wGBH2JUwTpMCQQLVb6k,16388
+ko_observability/structlog_bridge.py,sha256=5OMF2WAxC1KPd4ugYHlpGWq1oQ3R9CtOLtKwjlpFdz4,4471
+ko_observability-0.2.0.dist-info/METADATA,sha256=yhfqlHSi1AgphkKccInrn3csoSW9gpkaW0r3ZWQPQm4,4088
+ko_observability-0.2.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+ko_observability-0.2.0.dist-info/RECORD,,

ko_observability-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.3
+Root-Is-Purelib: true
+Tag: py3-none-any