reqly 0.1.0__py3-none-any.whl

reqly/__init__.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import logging
+
+from .core.client import ReqlyClient
+from .core.config import Config
+
+__version__ = "0.1.0"
+__all__ = ["instrument"]
+
+logger = logging.getLogger("reqly")
+
+# Keep a reference on each instrumented app so repeated calls / shutdown
+# hooks can find the client without the caller having to hold onto it.
+_CLIENTS: dict[int, ReqlyClient] = {}
+
+
+def _detect_framework(app) -> str:
+    module = type(app).__module__ or ""
+    if "flask" in module:
+        return "flask"
+    if "fastapi" in module or "starlette" in module:
+        return "fastapi"
+    # Fallback to duck typing if the module name isn't conclusive.
+    if hasattr(app, "add_middleware"):
+        return "fastapi"
+    if hasattr(app, "before_request") and hasattr(app, "wsgi_app"):
+        return "flask"
+    raise TypeError(
+        "reqly.instrument(): could not detect framework for app of type "
+        f"{type(app)!r}. Supported: FastAPI, Flask."
+    )
+
+
+def instrument(
+    app,
+    *,
+    service_name: str | None = None,
+    collector_url: str | None = None,
+    api_key: str | None = None,
+    sample_rate: float | None = None,
+    flush_interval_seconds: float | None = None,
+    max_batch_size: int | None = None,
+    max_queue_size: int | None = None,
+    ignore_routes: list[str] | None = None,
+    capture_request_body: bool | None = None,
+) -> ReqlyClient:
+    """Instrument a FastAPI or Flask app with one line.
+
+    Config resolution order for any omitted argument: explicit kwarg >
+    environment variable (REQLY_*) > default. See core.config.Config
+    for the full list of environment variables.
+
+    This function itself is guarded: a failure to detect the framework or
+    initialize the client is logged and the app is returned uninstrumented
+    rather than raising, so adding Reqly can never be the reason an
+    app fails to start.
+    """
+    try:
+        framework = _detect_framework(app)
+        config = Config.resolve(
+            service_name=service_name,
+            collector_url=collector_url,
+            api_key=api_key,
+            sample_rate=sample_rate,
+            flush_interval_seconds=flush_interval_seconds,
+            max_batch_size=max_batch_size,
+            max_queue_size=max_queue_size,
+            ignore_routes=ignore_routes,
+            capture_request_body=capture_request_body,
+        )
+        client = ReqlyClient(config)
+
+        if framework == "fastapi":
+            from .integrations.fastapi import instrument_fastapi
+
+            instrument_fastapi(app, client)
+        else:
+            from .integrations.flask import instrument_flask
+
+            instrument_flask(app, client)
+
+        _CLIENTS[id(app)] = client
+        return client
+    except Exception:
+        logger.warning(
+            "reqly: instrument() failed, app will run uninstrumented",
+            exc_info=True,
+        )
+        return None

reqly/core/buffer.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import atexit
+import logging
+import threading
+import time
+from collections import deque
+
+from .capture import RequestEvent
+from .shipper import Shipper
+
+logger = logging.getLogger("reqly")
+
+
+class EventBuffer:
+    """Bounded in-memory queue + background flush thread.
+
+    A single daemon thread mechanism is used for both sync (Flask) and async
+    (FastAPI) hosts so the core stays identical regardless of framework --
+    deliberately simple over clever (no asyncio.create_task path for FastAPI).
+
+    Backpressure: if the queue is full when a new event arrives, the oldest
+    entry is dropped and a counter incremented. The calling request thread
+    never blocks waiting for queue space.
+    """
+
+    def __init__(
+        self,
+        shipper: Shipper,
+        max_queue_size: int = 2000,
+        max_batch_size: int = 200,
+        flush_interval_seconds: float = 5.0,
+    ) -> None:
+        self._shipper = shipper
+        self._max_batch_size = max_batch_size
+        self._flush_interval_seconds = flush_interval_seconds
+
+        self._queue: deque[RequestEvent] = deque(maxlen=max_queue_size)
+        self._lock = threading.Lock()
+        self._dropped_events = 0
+
+        self._stop_event = threading.Event()
+        self._thread = threading.Thread(
+            target=self._run, name="reqly-flush", daemon=True
+        )
+        self._thread.start()
+        atexit.register(self.shutdown)
+
+    def add(self, event: RequestEvent) -> None:
+        with self._lock:
+            if len(self._queue) >= self._queue.maxlen:
+                self._dropped_events += 1
+            self._queue.append(event)
+
+    def _drain_batch(self) -> list[RequestEvent]:
+        with self._lock:
+            batch = []
+            while self._queue and len(batch) < self._max_batch_size:
+                batch.append(self._queue.popleft())
+            return batch
+
+    def _run(self) -> None:
+        while not self._stop_event.is_set():
+            self._stop_event.wait(self._flush_interval_seconds)
+            self.flush()
+
+    def flush(self) -> None:
+        try:
+            while True:
+                batch = self._drain_batch()
+                if not batch:
+                    return
+                self._shipper.send_batch(batch)
+                if len(batch) < self._max_batch_size:
+                    return
+        except Exception:
+            logger.warning("reqly: unexpected error during flush", exc_info=True)
+
+    def shutdown(self) -> None:
+        if self._stop_event.is_set():
+            return
+        self._stop_event.set()
+        try:
+            self.flush()
+        finally:
+            self._shipper.close()
+
+    def stats(self) -> dict:
+        with self._lock:
+            return {
+                "queued_events": len(self._queue),
+                "dropped_events": self._dropped_events,
+                "shipped_events": self._shipper.shipped_events,
+                "dropped_batches": self._shipper.dropped_batches,
+            }

reqly/core/capture.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import socket
+import uuid
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+
+_HOSTNAME = socket.gethostname()
+
+
+@dataclass
+class RequestEvent:
+    """One captured request. ``route`` MUST be the normalized route template
+    (e.g. "/users/{id}"), never the raw path (e.g. "/users/123") -- every
+    downstream aggregate's cardinality depends on this.
+    """
+
+    event_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    service_name: str = ""
+    timestamp: str = field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat()
+    )
+    method: str = "GET"
+    route: str = "/"
+    status_code: int = 200
+    duration_ms: float = 0.0
+    error: bool = False
+    error_type: str | None = None
+    host: str = _HOSTNAME
+    sdk_version: str = "0.1.0"
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def normalize_route(raw_path: str, matched_template: str | None) -> str:
+    """Return the route template if one was matched by the framework's
+    router; otherwise collapse to a single bucket so unmatched paths
+    (404s, scanners hitting random URLs) can't blow up cardinality.
+    """
+    if matched_template:
+        return matched_template
+    return "__unmatched__"
+
+
+def build_event(
+    *,
+    service_name: str,
+    method: str,
+    route: str,
+    status_code: int,
+    duration_ms: float,
+    error: bool,
+    error_type: str | None,
+    sdk_version: str,
+) -> RequestEvent:
+    return RequestEvent(
+        service_name=service_name,
+        method=method,
+        route=route,
+        status_code=status_code,
+        duration_ms=duration_ms,
+        error=error,
+        error_type=error_type,
+        sdk_version=sdk_version,
+    )

reqly/core/client.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import logging
+
+from .buffer import EventBuffer
+from .capture import build_event
+from .config import Config
+from .sampling import Sampler
+from .shipper import Shipper
+
+logger = logging.getLogger("reqly")
+
+
+class ReqlyClient:
+    """Wires config + sampler + shipper + buffer together for one
+    instrumented app, and enforces the SDK's core non-functional guarantee:
+    instrumentation errors must NEVER propagate into the host application.
+
+    Every public method here is internally guarded -- on the first internal
+    failure, instrumentation disables itself (logs once, then becomes a
+    no-op) rather than risk repeatedly raising into the host app's request
+    path.
+    """
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self._disabled = False
+        self._ignore_routes = set(config.ignore_routes)
+
+        try:
+            self._sampler = Sampler(config.sample_rate)
+            shipper = Shipper(
+                collector_url=config.collector_url,
+                api_key=config.api_key,
+                service_name=config.service_name,
+                sdk_version=config.sdk_version,
+            )
+            self._buffer = EventBuffer(
+                shipper=shipper,
+                max_queue_size=config.max_queue_size,
+                max_batch_size=config.max_batch_size,
+                flush_interval_seconds=config.flush_interval_seconds,
+            )
+        except Exception:
+            logger.warning(
+                "reqly: failed to initialize, instrumentation disabled",
+                exc_info=True,
+            )
+            self._disabled = True
+
+    def record_request(
+        self,
+        *,
+        method: str,
+        route: str,
+        status_code: int,
+        duration_ms: float,
+        error: bool,
+        error_type: str | None,
+    ) -> None:
+        if self._disabled:
+            return
+        try:
+            if route in self._ignore_routes:
+                return
+            if not self._sampler.should_sample():
+                return
+            event = build_event(
+                service_name=self.config.service_name,
+                method=method,
+                route=route,
+                status_code=status_code,
+                duration_ms=duration_ms,
+                error=error,
+                error_type=error_type,
+                sdk_version=self.config.sdk_version,
+            )
+            self._buffer.add(event)
+        except Exception:
+            logger.warning(
+                "reqly: internal error, disabling instrumentation",
+                exc_info=True,
+            )
+            self._disabled = True
+
+    def stats(self) -> dict:
+        if self._disabled:
+            return {"disabled": True}
+        return {"disabled": False, **self._buffer.stats(), **self._sampler.stats()}
+
+    def shutdown(self) -> None:
+        if self._disabled:
+            return
+        try:
+            self._buffer.shutdown()
+        except Exception:
+            pass

reqly/core/config.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name)
+    if raw is None or raw == "":
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def _env_int(name: str, default: int) -> int:
+    raw = os.environ.get(name)
+    if raw is None or raw == "":
+        return default
+    try:
+        return int(raw)
+    except ValueError:
+        return default
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None or raw == "":
+        return default
+    return raw.strip().lower() in ("1", "true", "yes", "on")
+
+
+@dataclass
+class Config:
+    """Resolved configuration for an instrumented app.
+
+    Resolution order for any field passed as None to ``instrument()``:
+    explicit kwarg > environment variable > default.
+    """
+
+    service_name: str
+    collector_url: str = "http://localhost:8000"
+    api_key: str | None = None
+    sample_rate: float = 1.0
+    flush_interval_seconds: float = 5.0
+    max_batch_size: int = 200
+    max_queue_size: int = 2000
+    ignore_routes: list[str] = field(default_factory=lambda: ["/health", "/metrics"])
+    capture_request_body: bool = False
+    sdk_version: str = "0.1.0"
+
+    @classmethod
+    def resolve(
+        cls,
+        service_name: str | None,
+        collector_url: str | None,
+        api_key: str | None,
+        sample_rate: float | None,
+        flush_interval_seconds: float | None,
+        max_batch_size: int | None,
+        max_queue_size: int | None,
+        ignore_routes: list[str] | None,
+        capture_request_body: bool | None,
+    ) -> "Config":
+        import sys as _sys
+
+        resolved_service_name = (
+            service_name
+            or os.environ.get("REQLY_SERVICE_NAME")
+            or (os.path.basename(_sys.argv[0]) if _sys.argv and _sys.argv[0] else None)
+            or "unnamed-service"
+        )
+
+        return cls(
+            service_name=resolved_service_name,
+            collector_url=(
+                collector_url
+                or os.environ.get("REQLY_COLLECTOR_URL")
+                or "http://localhost:8000"
+            ),
+            api_key=api_key or os.environ.get("REQLY_API_KEY"),
+            sample_rate=(
+                sample_rate
+                if sample_rate is not None
+                else _env_float("REQLY_SAMPLE_RATE", 1.0)
+            ),
+            flush_interval_seconds=(
+                flush_interval_seconds
+                if flush_interval_seconds is not None
+                else _env_float("REQLY_FLUSH_INTERVAL_SECONDS", 5.0)
+            ),
+            max_batch_size=(
+                max_batch_size
+                if max_batch_size is not None
+                else _env_int("REQLY_MAX_BATCH_SIZE", 200)
+            ),
+            max_queue_size=(
+                max_queue_size
+                if max_queue_size is not None
+                else _env_int("REQLY_MAX_QUEUE_SIZE", 2000)
+            ),
+            ignore_routes=(
+                ignore_routes
+                if ignore_routes is not None
+                else (os.environ.get("REQLY_IGNORE_ROUTES", "/health,/metrics").split(","))
+            ),
+            capture_request_body=(
+                capture_request_body
+                if capture_request_body is not None
+                else _env_bool("REQLY_CAPTURE_REQUEST_BODY", False)
+            ),
+        )

reqly/core/sampling.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import random
+import threading
+
+
+class Sampler:
+    """Decides whether a given request should be kept.
+
+    Unsampled requests still increment ``observed_count`` so that volume and
+    rate metrics can be corrected downstream by ``1 / sample_rate``. Default
+    sample_rate is 1.0 (no sampling) -- this exists as a documented config
+    knob, not because this project's traffic needs it.
+    """
+
+    def __init__(self, sample_rate: float = 1.0) -> None:
+        self.sample_rate = max(0.0, min(1.0, sample_rate))
+        self._lock = threading.Lock()
+        self.observed_count = 0
+        self.sampled_count = 0
+
+    def should_sample(self) -> bool:
+        with self._lock:
+            self.observed_count += 1
+            if self.sample_rate >= 1.0:
+                self.sampled_count += 1
+                return True
+            keep = random.random() < self.sample_rate
+            if keep:
+                self.sampled_count += 1
+            return keep
+
+    def stats(self) -> dict:
+        with self._lock:
+            return {
+                "observed_count": self.observed_count,
+                "sampled_count": self.sampled_count,
+                "sample_rate": self.sample_rate,
+            }

reqly/core/shipper.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import logging
+import random
+import time
+
+import httpx
+
+from .capture import RequestEvent
+
+logger = logging.getLogger("reqly")
+
+_MAX_RETRIES = 3
+_BACKOFF_BASE_SECONDS = 0.5
+
+
+class Shipper:
+    """Ships batches of events to the collector over HTTP.
+
+    Built on httpx with explicit per-phase timeouts so a slow or unreachable
+    collector can NEVER block the host application's request path -- this
+    client is only ever used from the buffer's background flush thread, never
+    inline with a request.
+    """
+
+    def __init__(
+        self,
+        collector_url: str,
+        api_key: str | None,
+        service_name: str,
+        sdk_version: str,
+    ) -> None:
+        self._service_name = service_name
+        self._sdk_version = sdk_version
+        self.dropped_batches = 0
+        self.shipped_events = 0
+
+        headers = {"Content-Type": "application/json"}
+        if api_key:
+            headers["X-Reqly-Key"] = api_key
+
+        self._client = httpx.Client(
+            base_url=collector_url.rstrip("/"),
+            headers=headers,
+            timeout=httpx.Timeout(connect=1.0, read=2.0, write=2.0, pool=1.0),
+            http2=False,
+        )
+
+    def send_batch(self, events: list[RequestEvent]) -> bool:
+        if not events:
+            return True
+
+        payload = {
+            "service_name": self._service_name,
+            "sdk_version": self._sdk_version,
+            "events": [e.to_dict() for e in events],
+        }
+
+        for attempt in range(_MAX_RETRIES):
+            try:
+                response = self._client.post("/v1/ingest", json=payload)
+                if response.status_code < 500:
+                    self.shipped_events += len(events)
+                    return True
+                logger.debug(
+                    "reqly: collector returned %s, attempt %d/%d",
+                    response.status_code,
+                    attempt + 1,
+                    _MAX_RETRIES,
+                )
+            except httpx.HTTPError as exc:
+                logger.debug(
+                    "reqly: shipper error %s, attempt %d/%d",
+                    exc,
+                    attempt + 1,
+                    _MAX_RETRIES,
+                )
+
+            if attempt < _MAX_RETRIES - 1:
+                backoff = _BACKOFF_BASE_SECONDS * (2**attempt)
+                time.sleep(backoff + random.uniform(0, 0.1))
+
+        self.dropped_batches += 1
+        logger.warning(
+            "reqly: dropped a batch of %d events after %d retries",
+            len(events),
+            _MAX_RETRIES,
+        )
+        return False
+
+    def close(self) -> None:
+        try:
+            self._client.close()
+        except Exception:
+            pass

reqly/integrations/fastapi.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import time
+
+from ..core.capture import normalize_route
+from ..core.client import ReqlyClient
+
+
+class ReqlyASGIMiddleware:
+    """Pure ASGI middleware (not Starlette's BaseHTTPMiddleware, which
+    buffers streaming response bodies). Wraps ``send`` to intercept the
+    ``http.response.start`` message for the status code, and measures
+    duration at the point the response completes.
+
+    The route template is only known AFTER the inner app has routed the
+    request (Starlette sets ``scope["route"]`` during dispatch), so the
+    timer starts before calling the inner app and the route is read from
+    the (mutated in place) scope dict afterward.
+    """
+
+    def __init__(self, app, client: ReqlyClient) -> None:
+        self.app = app
+        self._client = client
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        start = time.perf_counter()
+        status_code = 500
+        error = False
+        error_type = None
+
+        async def send_wrapper(message):
+            nonlocal status_code
+            if message["type"] == "http.response.start":
+                status_code = message["status"]
+            await send(message)
+
+        try:
+            await self.app(scope, receive, send_wrapper)
+        except Exception as exc:
+            error = True
+            error_type = type(exc).__name__
+            status_code = 500
+            raise
+        finally:
+            duration_ms = (time.perf_counter() - start) * 1000
+            route = scope.get("route")
+            route_template = getattr(route, "path", None) if route else None
+            normalized = normalize_route(scope.get("path", "/"), route_template)
+            self._client.record_request(
+                method=scope.get("method", "GET"),
+                route=normalized,
+                status_code=status_code,
+                duration_ms=duration_ms,
+                error=error or status_code >= 500,
+                error_type=error_type,
+            )
+
+
+def instrument_fastapi(app, client: ReqlyClient) -> None:
+    app.add_middleware(ReqlyASGIMiddleware, client=client)

reqly/integrations/flask.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import time
+
+from ..core.capture import normalize_route
+from ..core.client import ReqlyClient
+
+_START_TIME_ATTR = "_REQLY_start_time"
+
+
+def instrument_flask(app, client: ReqlyClient) -> None:
+    """Flask is WSGI, not ASGI -- uses request lifecycle signals rather than
+    wrapping ``app.wsgi_app`` directly. ``teardown_request`` matters
+    specifically because it fires even on unhandled exceptions, which is
+    exactly when error telemetry is most valuable.
+    """
+    from flask import g, request
+
+    @app.before_request
+    def _REQLY_before_request():
+        setattr(g, _START_TIME_ATTR, time.perf_counter())
+
+    @app.teardown_request
+    def _REQLY_teardown_request(exc):
+        start = getattr(g, _START_TIME_ATTR, None)
+        if start is None:
+            return
+        duration_ms = (time.perf_counter() - start) * 1000
+
+        route_template = None
+        if request.url_rule is not None:
+            route_template = request.url_rule.rule
+        normalized = normalize_route(request.path, route_template)
+
+        if exc is not None:
+            status_code = 500
+            error = True
+            error_type = type(exc).__name__
+        else:
+            response = getattr(g, "_REQLY_response_status", None)
+            status_code = response if response is not None else 200
+            error = status_code >= 500
+            error_type = None
+
+        client.record_request(
+            method=request.method,
+            route=normalized,
+            status_code=status_code,
+            duration_ms=duration_ms,
+            error=error,
+            error_type=error_type,
+        )
+
+    @app.after_request
+    def _REQLY_after_request(response):
+        g._REQLY_response_status = response.status_code
+        return response

reqly-0.1.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: reqly
+Version: 0.1.0
+Summary: Auto-instrumentation SDK for FastAPI and Flask: zero-code latency, error rates, and status codes shipped to a Reqly collector.
+Author: reqly
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tanisheesh/reqly
+Project-URL: Repository, https://github.com/tanisheesh/reqly
+Project-URL: Issues, https://github.com/tanisheesh/reqly/issues
+Project-URL: Documentation, https://github.com/tanisheesh/reqly/blob/main/CONTRIBUTING.md
+Keywords: observability,apm,monitoring,fastapi,flask,telemetry,metrics,latency,tracing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Flask
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1.0,>=0.27
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100; extra == "fastapi"
+Provides-Extra: flask
+Requires-Dist: flask>=2.3; extra == "flask"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: fastapi>=0.100; extra == "dev"
+Requires-Dist: flask>=2.3; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+
+# Reqly
+
+Auto-instrumentation SDK for FastAPI and Flask. One line captures latency, status codes, and error rates for every request and ships them to an [Reqly collector](../collector).
+
+## Install
+
+```bash
+pip install reqly
+```
+
+(For local development against this monorepo: `pip install -e ./sdk[dev]`.)
+
+## Usage
+
+```python
+from fastapi import FastAPI
+import reqly
+
+app = FastAPI()
+reqly.instrument(app, service_name="checkout-api")
+```
+
+```python
+from flask import Flask
+import reqly
+
+app = Flask(__name__)
+reqly.instrument(app, service_name="checkout-api")
+```
+
+`instrument()` auto-detects FastAPI vs Flask — no other code changes needed.
+
+## Configuration
+
+Every option can be passed as a kwarg to `instrument()` or set via environment variable. Resolution order: kwarg > env var > default.
+
+| kwarg | env var | default |
+|---|---|---|
+| `service_name` | `REQLY_SERVICE_NAME` | `sys.argv[0]` basename |
+| `collector_url` | `REQLY_COLLECTOR_URL` | `http://localhost:8000` |
+| `api_key` | `REQLY_API_KEY` | `None` |
+| `sample_rate` | `REQLY_SAMPLE_RATE` | `1.0` |
+| `flush_interval_seconds` | `REQLY_FLUSH_INTERVAL_SECONDS` | `5.0` |
+| `max_batch_size` | `REQLY_MAX_BATCH_SIZE` | `200` |
+| `max_queue_size` | `REQLY_MAX_QUEUE_SIZE` | `2000` |
+| `ignore_routes` | `REQLY_IGNORE_ROUTES` (comma-separated) | `/health,/metrics` |
+| `capture_request_body` | `REQLY_CAPTURE_REQUEST_BODY` | `False` |
+
+## Design guarantees
+
+- **Fails open.** Any internal SDK error is caught and logged once; instrumentation then disables itself rather than risk repeatedly raising into your app. A slow or unreachable collector never slows down your app — all shipping happens off a background thread with strict per-phase HTTP timeouts.
+- **Bounded cardinality.** Captured routes are the framework's matched route *template* (`/users/{id}`), never the raw path (`/users/123`). Unmatched paths (404s, scanners) collapse into a single `__unmatched__` bucket instead of blowing up cardinality.
+- **Bounded memory.** Events are held in a fixed-size in-memory queue; under sustained backpressure, the oldest events are dropped (and counted) rather than growing unbounded or blocking request threads.
+
+## Architecture
+
+See [`../ARCHITECTURE.md`](../ARCHITECTURE.md#2-sdk-design) for the full design rationale (why pure ASGI middleware over `BaseHTTPMiddleware`, why a background thread over `asyncio.create_task`, why `httpx` over `requests`, etc).
+
+## Running tests
+
+```bash
+pip install -e .[dev]
+pytest
+```

reqly-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+reqly/__init__.py,sha256=IRpMogn8kkSO_Um-jzG93SCR1xRiI1R-iPMkMYeA9_Q,2893
+reqly/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reqly/core/buffer.py,sha256=Ufsw_8KT_K6gvrzYWkp49U0kHdbEOWGTkqMiefq_CdI,2998
+reqly/core/capture.py,sha256=6KYr_pZlcARD2EVnTQJAAWnqLk1mNyAy6iMDGZ3VcTY,1761
+reqly/core/client.py,sha256=GYNZgyRgCDz1VKcABPZ3xeeTutxEhhGk6CZAHhJwTwo,3026
+reqly/core/config.py,sha256=78yrdynprkchC2h4qH5XdrKjY93CY3BaLPtfFZLQhwI,3476
+reqly/core/sampling.py,sha256=3-QyPzE3KWqYq5Gk4I6DcsZg3bz9ONZqoo7_6A8LVxA,1245
+reqly/core/shipper.py,sha256=h3f8F1Fny9lHVd8axJ5HttgQpGvd5Xf0kIl6Yy4fHCE,2727
+reqly/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reqly/integrations/fastapi.py,sha256=M_4IXJSLJGxEIkapBnnAGYCx0s5Mren6VppJfNeUKcs,2218
+reqly/integrations/flask.py,sha256=DDNpJoOBX50j4_Zp1607BslYj8zcSD7narCRPUWp7Ek,1795
+reqly-0.1.0.dist-info/METADATA,sha256=zrRF3Y6_ZsPPi3P-oPvnxUdlAzKJOLTe5hvaeMyQI_E,4119
+reqly-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+reqly-0.1.0.dist-info/top_level.txt,sha256=gAwxcUgGJPEqEOijYFYSnP5Gdaxc0KCKC8VyvsuIRWs,6
+reqly-0.1.0.dist-info/RECORD,,

reqly-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

reqly-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+reqly