servicedna 0.1.0__py3-none-any.whl

servicedna/__init__.py

@@ -0,0 +1,40 @@
+"""ServiceDNA SDK for Python.
+
+Run a program with telemetry (recommended — instruments libraries before they're imported):
+
+    servicedna-run uvicorn app.main:app
+
+Or start it from code, first thing in your entry point:
+
+    import servicedna
+    servicedna.start()
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+
+from . import config as _config
+from .bodies import capture, tag
+
+__all__ = ["start", "capture", "tag"]
+__version__ = "0.1.0"
+
+log = logging.getLogger("servicedna")
+
+
+def start() -> bool:
+    """Configures tracing, instruments installed libraries, and starts heartbeats. Returns False
+    (and does nothing) when SERVICEDNA_URL and SERVICEDNA_KEY aren't set."""
+    cfg = _config.resolve()
+    if not cfg.enabled:
+        log.warning("[servicedna] SERVICEDNA_URL and SERVICEDNA_KEY are not set; not sending telemetry")
+        return False
+    for key, value in _config.otel_environment(cfg).items():
+        os.environ.setdefault(key, value)
+
+    from opentelemetry.instrumentation.auto_instrumentation import initialize
+
+    initialize()  # loads the servicedna distro (which starts the heartbeat) and configurator
+    return True

servicedna/bodies.py

@@ -0,0 +1,127 @@
+"""Request/response body capture for ServiceDNA. Requests carrying the baggage entry
+``sdna.capture=1`` (test runs) are always captured. With ``SERVICEDNA_CAPTURE_ON_ERROR=true``,
+every other request's bodies are held until its response and recorded only if it failed (5xx) —
+successful traffic ships no payloads. Bodies are masked and truncated before being recorded on the
+request's server span."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+
+from opentelemetry import baggage, trace
+
+MAX_BYTES = int(os.getenv("SERVICEDNA_CAPTURE_MAX_BYTES", "16384"))
+_SENSITIVE = re.compile(r"pass(word|wd)?|secret|token|api[-_.]?key|authorization|cookie|session|card|cvv|ssn", re.I)
+_SCOPE_KEY = "servicedna.capture"
+
+
+def capture_on_error() -> bool:
+    return os.getenv("SERVICEDNA_CAPTURE_ON_ERROR", "").lower() in ("1", "true", "yes")
+
+
+def capture_requested() -> bool:
+    return baggage.get_baggage("sdna.capture") == "1"
+
+
+def redact(text: str) -> str:
+    """Masks credential-like fields in JSON; other text is kept. Always truncates."""
+    try:
+        text = json.dumps(_mask(json.loads(text)), separators=(",", ":"))
+    except (ValueError, TypeError):
+        pass
+    return text if len(text) <= MAX_BYTES else text[:MAX_BYTES] + "…[truncated]"
+
+
+def _mask(value):
+    if isinstance(value, dict):
+        return {k: "[masked]" if _SENSITIVE.search(str(k)) else _mask(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_mask(v) for v in value]
+    return value
+
+
+def capture(name: str, value) -> None:
+    """Records a value computed inside the service on the current span, for test runs:
+    ``servicedna.capture("order.total", total)``. Does nothing outside a capture run."""
+    if not capture_requested():
+        return
+    span = trace.get_current_span()
+    if span.is_recording():
+        text = value if isinstance(value, str) else json.dumps(value, default=str)
+        span.set_attribute(f"sdna.capture.{name}", redact(text))
+
+
+def tag(name: str, value) -> None:
+    """Tags the current span with a business key, so ServiceDNA can follow it across services,
+    traces and logs — even where trace context was lost: ``servicedna.tag("orderId", order_id)``.
+    Unlike capture(), it applies to all traffic; use ids, not personal data."""
+    if value is None:
+        return
+    span = trace.get_current_span()
+    if span.is_recording():
+        span.set_attribute(f"sdna.key.{name}", str(value))
+
+
+# ASGI instrumentation hooks (FastAPI, Starlette). The receive/send hooks run on the
+# instrumentation's own receive/send spans, so the server span is remembered on the ASGI scope.
+
+
+def server_request_hook(span, scope):
+    if span is None or not span.is_recording():
+        return
+    if capture_requested():
+        scope[_SCOPE_KEY] = {"span": span, "on_error": False, "status": None, "request": bytearray(), "response": bytearray()}
+    elif capture_on_error():
+        scope[_SCOPE_KEY] = {"span": span, "on_error": True, "status": None, "request": bytearray(), "response": bytearray()}
+
+
+def client_request_hook(span, scope, message):
+    state = scope.get(_SCOPE_KEY)
+    if state is not None and message.get("type") == "http.request":
+        _append(state["request"], message.get("body", b""))
+
+
+def client_response_hook(span, scope, message):
+    state = scope.get(_SCOPE_KEY)
+    if state is None:
+        return
+    if message.get("type") == "http.response.start":
+        state["status"] = message.get("status")
+        return
+    if message.get("type") != "http.response.body":
+        return
+    _append(state["response"], message.get("body", b""))
+    if not message.get("more_body", False):
+        scope.pop(_SCOPE_KEY, None)
+        server_span = state["span"]
+        if state["on_error"]:
+            if (state["status"] or 0) < 500:
+                return
+            server_span.set_attribute("sdna.captured_on_error", True)
+        else:
+            server_span.set_attribute("sdna.captured", True)
+        if state["request"]:
+            server_span.set_attribute("sdna.request.body", redact(state["request"].decode("utf-8", "replace")))
+        if state["response"]:
+            server_span.set_attribute("sdna.response.body", redact(state["response"].decode("utf-8", "replace")))
+
+
+def _append(buffer: bytearray, chunk: bytes) -> None:
+    if chunk and len(buffer) <= MAX_BYTES:
+        buffer.extend(chunk)
+
+
+def instrument_fastapi() -> bool:
+    """Instruments FastAPI with body capture. Returns False if FastAPI instrumentation isn't installed."""
+    try:
+        from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+    except ImportError:
+        return False
+    FastAPIInstrumentor().instrument(
+        server_request_hook=server_request_hook,
+        client_request_hook=client_request_hook,
+        client_response_hook=client_response_hook,
+    )
+    return True

servicedna/config.py

@@ -0,0 +1,88 @@
+"""Resolves SDK settings from environment variables. Only SERVICEDNA_URL and SERVICEDNA_KEY are
+required; everything else has a default."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Mapping, Optional
+
+
+@dataclass(frozen=True)
+class Config:
+    url: str
+    key: str
+    service_name: str
+    environment: Optional[str]
+    version: Optional[str]
+    health_url: Optional[str]  # what ServiceDNA probes; only reported when set
+    local_health_url: Optional[str]  # what the heartbeat checks, over loopback
+    heartbeat_seconds: float
+    degraded_ms: int
+    logs: bool = True  # SERVICEDNA_LOGS=false stops sending the logging module's records
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.url and self.key)
+
+
+def resolve(env: Mapping[str, str] = os.environ) -> Config:
+    port = env.get("PORT")
+    health_path = env.get("SERVICEDNA_HEALTH_PATH", "/health")
+    return Config(
+        url=env.get("SERVICEDNA_URL", "").rstrip("/"),
+        key=env.get("SERVICEDNA_KEY", ""),
+        service_name=env.get("OTEL_SERVICE_NAME") or env.get("SERVICEDNA_SERVICE") or _default_service_name(),
+        environment=env.get("SERVICEDNA_ENV") or None,
+        version=env.get("SERVICEDNA_VERSION") or None,
+        health_url=env.get("SERVICEDNA_HEALTH_URL") or None,
+        local_health_url=env.get("SERVICEDNA_LOCAL_HEALTH_URL")
+        or (f"http://127.0.0.1:{port}{health_path}" if port else None),
+        heartbeat_seconds=int(env.get("SERVICEDNA_HEARTBEAT_MS", "15000")) / 1000,
+        degraded_ms=int(env.get("SERVICEDNA_DEGRADED_MS", "2000")),
+        logs=env.get("SERVICEDNA_LOGS", "true").lower() not in ("0", "false", "no", "off"),
+    )
+
+
+def _default_service_name() -> str:
+    return os.path.basename(os.getcwd()) or "unknown_service:python"
+
+
+def otel_environment(config: Config) -> dict:
+    """The OTEL_* settings that send this service's traces and logs to ServiceDNA. Values the user already
+    set are respected by the caller (setdefault), so standard OpenTelemetry configuration still
+    works."""
+    attributes = [f"telemetry.sdk.language=python"]
+    if config.environment:
+        attributes.append(f"deployment.environment.name={config.environment}")
+    if config.version:
+        attributes.append(f"service.version={config.version}")
+    if config.health_url:
+        attributes.append(f"servicedna.health.url={config.health_url}")
+    excluded = [config.local_health_url.split("://", 1)[1].split("/", 1)[1]] if config.local_health_url else []
+    logs = (
+        {
+            # Records from the logging module, with the active trace and span ids.
+            "OTEL_LOGS_EXPORTER": "otlp",
+            "OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED": "true",
+            "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL": "http/protobuf",
+            "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT": f"{config.url}/api/v1/otlp/v1/logs",
+            "OTEL_EXPORTER_OTLP_LOGS_HEADERS": f"x-servicedna-key={config.key}",
+        }
+        if config.logs
+        else {"OTEL_LOGS_EXPORTER": "none"}
+    )
+    return {
+        "OTEL_SERVICE_NAME": config.service_name,
+        "OTEL_RESOURCE_ATTRIBUTES": ",".join(attributes),
+        "OTEL_TRACES_EXPORTER": "otlp",
+        "OTEL_METRICS_EXPORTER": "none",
+        **logs,
+        "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL": "http/protobuf",
+        "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT": f"{config.url}/api/v1/otlp/v1/traces",
+        "OTEL_EXPORTER_OTLP_TRACES_HEADERS": f"x-servicedna-key={config.key}",
+        # Health probes (ServiceDNA's and the heartbeat's) aren't traffic worth tracing.
+        "OTEL_PYTHON_EXCLUDED_URLS": ",".join(f"/{path}" for path in excluded),
+        "OTEL_PYTHON_DISTRO": "servicedna",
+        "OTEL_PYTHON_CONFIGURATOR": "servicedna",
+    }

servicedna/distro.py

@@ -0,0 +1,61 @@
+"""OpenTelemetry distro and configurator entry points, selected by OTEL_PYTHON_DISTRO /
+OTEL_PYTHON_CONFIGURATOR=servicedna (set by servicedna-run and servicedna.start)."""
+
+from __future__ import annotations
+
+import logging
+import os
+
+from opentelemetry.instrumentation.distro import BaseDistro
+from opentelemetry.sdk._configuration import _OTelSDKConfigurator
+
+from . import bodies as _bodies
+from . import grpc_capture as _grpc_capture
+from . import config as _config
+from . import heartbeat
+
+
+class ServiceDnaDistro(BaseDistro):
+    def _configure(self, **kwargs):
+        cfg = _config.resolve()
+        if not cfg.enabled:
+            return
+        for key, value in _config.otel_environment(cfg).items():
+            os.environ.setdefault(key, value)
+        # FastAPI is instrumented here, with body-capture hooks, instead of by auto-instrumentation.
+        if _bodies.instrument_fastapi():
+            disabled = [d for d in os.environ.get("OTEL_PYTHON_DISABLED_INSTRUMENTATIONS", "").split(",") if d]
+            os.environ["OTEL_PYTHON_DISABLED_INSTRUMENTATIONS"] = ",".join(disabled + ["fastapi"])
+        # gRPC request/response messages, for test runs (and failures with capture on error).
+        _grpc_capture.install()
+        if cfg.logs:
+            _bridge_uvicorn_logs()
+        heartbeat.start(cfg)
+
+
+def _bridge_uvicorn_logs() -> None:
+    """uvicorn's loggers don't propagate to the root logger, where OpenTelemetry's handler sits.
+    Once uvicorn has configured logging, its "uvicorn" logger (startup, errors and tracebacks —
+    not per-request access lines, which spans already cover) gets that handler too."""
+    try:
+        import uvicorn.config
+    except ImportError:
+        return
+    original = uvicorn.config.Config.configure_logging
+    if getattr(original, "_servicedna", False):
+        return
+
+    def configure_logging(self):
+        original(self)
+        handlers = [h for h in logging.getLogger().handlers if type(h).__name__ == "LoggingHandler"]
+        target = logging.getLogger("uvicorn")
+        for handler in handlers:
+            if handler not in target.handlers:
+                target.addHandler(handler)
+
+    configure_logging._servicedna = True
+    uvicorn.config.Config.configure_logging = configure_logging
+
+
+class ServiceDnaConfigurator(_OTelSDKConfigurator):
+    """The standard OpenTelemetry SDK setup (tracer provider, batch span processor, exporter)."""

servicedna/grpc_capture.py

@@ -0,0 +1,127 @@
+"""gRPC message capture: the request and response messages of unary calls a service handles,
+recorded on its server span as JSON (masked and truncated like HTTP bodies) — for ServiceDNA test
+runs (baggage ``sdna.capture=1``), and for failed calls with ``SERVICEDNA_CAPTURE_ON_ERROR=true``.
+
+Installed by the distro: servers made with ``grpc.server`` / ``grpc.aio.server`` get the
+interceptor after OpenTelemetry's, so the server span and the caller's baggage are current."""
+
+from __future__ import annotations
+
+import functools
+
+from opentelemetry import trace
+
+from .bodies import capture_on_error, capture_requested, redact
+
+
+def _json(message) -> str:
+    try:
+        from google.protobuf.json_format import MessageToJson
+
+        return MessageToJson(message, preserving_proto_field_name=True, indent=None)
+    except Exception:  # not a protobuf message
+        return str(message)
+
+
+def _record(span, request, response, requested: bool) -> None:
+    if not span.is_recording():
+        return
+    span.set_attribute("sdna.request.body", redact(_json(request)))
+    if response is not None:
+        span.set_attribute("sdna.response.body", redact(_json(response)))
+    span.set_attribute("sdna.captured" if requested else "sdna.captured_on_error", True)
+
+
+def _wrap_handler(handler, aio: bool):
+    import grpc
+
+    if handler is None or handler.unary_unary is None:
+        return handler  # streaming calls aren't captured
+    behavior = handler.unary_unary
+
+    if aio:
+
+        async def unary_unary(request, context):
+            requested = capture_requested()
+            if not requested and not capture_on_error():
+                return await behavior(request, context)
+            span = trace.get_current_span()
+            try:
+                response = await behavior(request, context)
+            except BaseException:
+                _record(span, request, None, requested)
+                raise
+            if requested:
+                _record(span, request, response, True)
+            return response
+
+    else:
+
+        def unary_unary(request, context):
+            requested = capture_requested()
+            if not requested and not capture_on_error():
+                return behavior(request, context)
+            span = trace.get_current_span()
+            try:
+                response = behavior(request, context)
+            except BaseException:
+                _record(span, request, None, requested)
+                raise
+            if requested:
+                _record(span, request, response, True)
+            return response
+
+    return grpc.unary_unary_rpc_method_handler(
+        unary_unary, request_deserializer=handler.request_deserializer, response_serializer=handler.response_serializer
+    )
+
+
+def server_interceptor():
+    import grpc
+
+    class CaptureInterceptor(grpc.ServerInterceptor):
+        def intercept_service(self, continuation, handler_call_details):
+            return _wrap_handler(continuation(handler_call_details), aio=False)
+
+    return CaptureInterceptor()
+
+
+def aio_server_interceptor():
+    import grpc.aio
+
+    class AioCaptureInterceptor(grpc.aio.ServerInterceptor):
+        async def intercept_service(self, continuation, handler_call_details):
+            return _wrap_handler(await continuation(handler_call_details), aio=True)
+
+    return AioCaptureInterceptor()
+
+
+def install() -> bool:
+    """Adds the capture interceptor to every gRPC server made from now on. False without grpcio."""
+    try:
+        import grpc
+        import grpc.aio
+    except ImportError:
+        return False
+    if getattr(grpc.server, "_servicedna", False):
+        return True
+
+    def patch(module, name, make):
+        original = getattr(module, name)
+
+        @functools.wraps(original)
+        def server(*args, **kwargs):
+            interceptors = list(kwargs.pop("interceptors", None) or [])
+            # grpc.server(thread_pool, handlers, interceptors, ...) also takes them positionally.
+            if module is grpc and len(args) >= 3:
+                interceptors = list(args[2] or []) + interceptors
+                args = args[:2] + args[3:]
+            interceptors.append(make())
+            return original(*args, interceptors=interceptors, **kwargs)
+
+        server._servicedna = True
+        setattr(module, name, server)
+
+    patch(grpc, "server", server_interceptor)
+    patch(grpc.aio, "server", aio_server_interceptor)
+    return True

servicedna/heartbeat.py

@@ -0,0 +1,84 @@
+"""Checks the service's own health endpoint on an interval and reports the result to ServiceDNA,
+which registers the service on first contact. Its HTTP calls are made with tracing suppressed so
+heartbeats don't show up as the service's traffic."""
+
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+import urllib.error
+import urllib.request
+
+from opentelemetry import context
+
+from .config import Config
+
+log = logging.getLogger("servicedna")
+_started = False
+
+
+def start(config: Config) -> None:
+    global _started
+    if _started or not config.local_health_url or config.heartbeat_seconds <= 0:
+        return
+    _started = True
+    thread = threading.Thread(target=_loop, args=(config,), name="servicedna-heartbeat", daemon=True)
+    thread.start()
+
+
+def _loop(config: Config) -> None:
+    while True:
+        time.sleep(config.heartbeat_seconds)
+        token = context.attach(context.set_value(context._SUPPRESS_INSTRUMENTATION_KEY, True))
+        try:
+            _beat(config)
+        except Exception as e:  # never let the heartbeat thread die
+            log.warning("[servicedna] heartbeat failed: %s", e)
+        finally:
+            context.detach(token)
+
+
+def _beat(config: Config) -> None:
+    start = time.monotonic()
+    status, message = "DOWN", "health check failed"
+    try:
+        with urllib.request.urlopen(config.local_health_url, timeout=5) as res:
+            body = res.read()
+            elapsed_ms = (time.monotonic() - start) * 1000
+            status = "DEGRADED" if elapsed_ms > config.degraded_ms else "HEALTHY"
+            message = _message(body) or f"HTTP {res.status}"
+    except urllib.error.HTTPError as e:
+        message = _message(e.read()) or f"HTTP {e.code}"
+    except Exception as e:
+        message = str(e) or type(e).__name__
+    latency_ms = int((time.monotonic() - start) * 1000)
+
+    payload = json.dumps(
+        {
+            "status": status,
+            "latencyMs": latency_ms,
+            "message": message[:500],
+            "service": config.service_name,
+            "environment": config.environment,
+        }
+    ).encode()
+    request = urllib.request.Request(
+        f"{config.url}/api/v1/ping",
+        data=payload,
+        headers={"Content-Type": "application/json", "X-API-Key": config.key},
+        method="POST",
+    )
+    try:
+        urllib.request.urlopen(request, timeout=5).close()
+    except urllib.error.HTTPError as e:
+        log.warning("[servicedna] heartbeat rejected: HTTP %s", e.code)
+
+
+def _message(body: bytes):
+    try:
+        data = json.loads(body)
+        return str(data.get("message") or data.get("status") or "") or None
+    except (ValueError, AttributeError):
+        return None

servicedna/run.py

@@ -0,0 +1,32 @@
+"""servicedna-run: run a Python program with ServiceDNA telemetry, e.g.
+
+    SERVICEDNA_URL=... SERVICEDNA_KEY=sdna_ik_... servicedna-run uvicorn app.main:app
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from . import config as _config
+
+
+def main() -> None:
+    cfg = _config.resolve()
+    if not cfg.enabled:
+        print("[servicedna] SERVICEDNA_URL and SERVICEDNA_KEY are not set; not sending telemetry", file=sys.stderr)
+    else:
+        for key, value in _config.otel_environment(cfg).items():
+            os.environ.setdefault(key, value)
+        print(
+            f"[servicedna] sending {cfg.service_name}"
+            + (f" ({cfg.environment})" if cfg.environment else "")
+            + f" telemetry to {cfg.url}",
+            file=sys.stderr,
+        )
+
+    # Same mechanism as opentelemetry-instrument: re-executes the command with auto-instrumentation
+    # loaded via sitecustomize, which picks up the servicedna distro and configurator.
+    from opentelemetry.instrumentation.auto_instrumentation import run
+
+    run()

servicedna-0.1.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.5
+Name: servicedna
+Version: 0.1.0
+Summary: Connect a Python service to ServiceDNA: traces, self-registration and health heartbeats with two environment variables.
+Project-URL: Source, https://github.com/varuns2903/servicedna/tree/main/sdks/python
+License-Expression: MIT
+Requires-Python: >=3.9
+Requires-Dist: opentelemetry-api~=1.45
+Requires-Dist: opentelemetry-exporter-otlp-proto-http~=1.45
+Requires-Dist: opentelemetry-instrumentation-aiohttp-client==0.66b0
+Requires-Dist: opentelemetry-instrumentation-asgi==0.66b0
+Requires-Dist: opentelemetry-instrumentation-confluent-kafka==0.66b0
+Requires-Dist: opentelemetry-instrumentation-django==0.66b0
+Requires-Dist: opentelemetry-instrumentation-fastapi==0.66b0
+Requires-Dist: opentelemetry-instrumentation-flask==0.66b0
+Requires-Dist: opentelemetry-instrumentation-grpc==0.66b0
+Requires-Dist: opentelemetry-instrumentation-httpx==0.66b0
+Requires-Dist: opentelemetry-instrumentation-kafka-python==0.66b0
+Requires-Dist: opentelemetry-instrumentation-psycopg2==0.66b0
+Requires-Dist: opentelemetry-instrumentation-redis==0.66b0
+Requires-Dist: opentelemetry-instrumentation-requests==0.66b0
+Requires-Dist: opentelemetry-instrumentation-sqlalchemy==0.66b0
+Requires-Dist: opentelemetry-instrumentation-urllib3==0.66b0
+Requires-Dist: opentelemetry-instrumentation-wsgi==0.66b0
+Requires-Dist: opentelemetry-instrumentation==0.66b0
+Requires-Dist: opentelemetry-sdk~=1.45
+Provides-Extra: test
+Requires-Dist: fastapi; extra == 'test'
+Requires-Dist: grpcio; extra == 'test'
+Requires-Dist: grpcio-health-checking; extra == 'test'
+Requires-Dist: httpx; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Requires-Dist: uvicorn; extra == 'test'
+Description-Content-Type: text/markdown
+
+# servicedna (Python)
+
+Connect a Python service to [ServiceDNA](https://github.com/varuns2903/servicedna) with one
+dependency and two environment variables. You get:
+
+- **Distributed traces** for FastAPI, Flask, Django, ASGI/WSGI, requests, httpx, urllib3,
+  aiohttp, gRPC, SQLAlchemy, psycopg2, Redis and Kafka (OpenTelemetry auto-instrumentation —
+  only libraries you actually use are instrumented)
+- **Self-registration** — the service appears in ServiceDNA on first start
+- **Health heartbeats** — the service's own `/health` is checked and reported every 15 s
+
+## Install
+
+```bash
+pip install servicedna
+```
+
+## Run
+
+Prefix your usual command with `servicedna-run`:
+
+```bash
+SERVICEDNA_URL=https://servicedna.example.com \
+SERVICEDNA_KEY=sdna_ik_... \
+servicedna-run uvicorn app.main:app --host 0.0.0.0 --port 8000
+```
+
+Or start it from code, first thing in your entry point:
+
+```python
+import servicedna
+servicedna.start()
+```
+
+`servicedna-run` is preferred: it instruments libraries before your code imports them. Without
+`SERVICEDNA_URL` and `SERVICEDNA_KEY` both do nothing, so the same build runs anywhere.
+
+## Configuration
+
+| Variable | Default | |
+|---|---|---|
+| `SERVICEDNA_URL` | — | ServiceDNA base URL (required) |
+| `SERVICEDNA_KEY` | — | Organization ingestion key, from Settings → Integrations (required) |
+| `SERVICEDNA_ENV` | — | Environment (`dev`, `staging`, `prod`…); each is tracked separately |
+| `OTEL_SERVICE_NAME` / `SERVICEDNA_SERVICE` | working directory name | Service name |
+| `SERVICEDNA_VERSION` | — | |
+| `SERVICEDNA_HEALTH_URL` | — | Health URL **ServiceDNA** can reach, so it can also probe the service itself |
+| `SERVICEDNA_HEALTH_PATH` | `/health` | Path the heartbeat checks on `http://127.0.0.1:$PORT` |
+| `SERVICEDNA_LOCAL_HEALTH_URL` | from `PORT` + path | Full URL the heartbeat checks, if not on `PORT` |
+| `SERVICEDNA_HEARTBEAT_MS` | `15000` | `0` disables heartbeats |
+| `SERVICEDNA_DEGRADED_MS` | `2000` | Health response slower than this is reported DEGRADED |
+
+Standard `OTEL_*` variables still apply and win over these defaults.

servicedna-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+servicedna/__init__.py,sha256=91OAiFRM2bT8Gi9WGCYO5J1tNw0qFoHo6uv0YHkOFL4,1169
+servicedna/bodies.py,sha256=_F6uNyafaXLwmBX95S0CpXrnAA7MgY5NVfbhPvOdgBI,4892
+servicedna/config.py,sha256=SxlrHX_iKwrER-B8o5vz-STGC0xTG38IwcDegEEtMhY,3803
+servicedna/distro.py,sha256=qvXAU1BYQ4Y5so98G6x5VXCQuA7WKUH6BvmDiIRam_Q,2424
+servicedna/grpc_capture.py,sha256=O_NxmTIHn3My3N9-tIdFkaSfhVZf5lKnDh2QYiE4IhM,4422
+servicedna/heartbeat.py,sha256=n5v5supePbcBBfMcJVogwa2_WpLh3bFcUDoympdWKIc,2726
+servicedna/run.py,sha256=3A3kHgfVowWccs0gkSvNae9lzNb2UaMTtVqBrf9gCvM,1053
+servicedna-0.1.0.dist-info/METADATA,sha256=ZULomMN6UcJcz1uq6WqZGCybCd0LtvDRWSfWd7_wU7Q,3894
+servicedna-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+servicedna-0.1.0.dist-info/entry_points.txt,sha256=4nI7fRCVAiHJlZWfuNXTImOk_zNQyJRvWyBk28HJ2bA,211
+servicedna-0.1.0.dist-info/RECORD,,

servicedna-0.1.0.dist-info/WHEEL

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

servicedna-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+servicedna-run = servicedna.run:main
+
+[opentelemetry_configurator]
+servicedna = servicedna.distro:ServiceDnaConfigurator
+
+[opentelemetry_distro]
+servicedna = servicedna.distro:ServiceDnaDistro