reqly 0.1.4__tar.gz → 0.3.0__tar.gz

reqly-0.3.0/PKG-INFO

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: reqly
+Version: 0.3.0
+Summary: Self-hosted API monitoring for FastAPI, Flask, Django, Starlette and Litestar in two lines: latency percentiles, error rates and release tracking per route, with deploy-aware alerts and weekly AI anomaly reports.
+Author: Tanish Poddar
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://reqly.tanisheesh.in
+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/docs/SETUP.md
+Project-URL: Changelog, https://github.com/tanisheesh/reqly/blob/main/sdk/CHANGELOG.md
+Project-URL: Live Demo, https://reqly-eventflow-dashboard.onrender.com
+Keywords: observability,apm,monitoring,fastapi,flask,django,starlette,litestar,telemetry,metrics,latency,percentiles,alerting,anomaly-detection,release-tracking,self-hosted,timescaledb
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Classifier: Framework :: Django
+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: starlette
+Requires-Dist: starlette>=0.27; extra == "starlette"
+Provides-Extra: litestar
+Requires-Dist: litestar>=2.0; extra == "litestar"
+Provides-Extra: flask
+Requires-Dist: flask>=2.3; extra == "flask"
+Provides-Extra: django
+Requires-Dist: django>=4.2; extra == "django"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: fastapi>=0.100; extra == "dev"
+Requires-Dist: litestar>=2.0; extra == "dev"
+Requires-Dist: flask>=2.3; extra == "dev"
+Requires-Dist: django>=4.2; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+
+# reqly
+
+**Self-hosted API monitoring for FastAPI, Flask, Django, Starlette and Litestar — two lines of code.**
+Latency percentiles, error rates and release tracking for every route, shipped to your own
+[Reqly](https://github.com/tanisheesh/reqly) collector — which turns them into deploy-aware
+hourly alerts and weekly AI anomaly reports.
+
+[![PyPI](https://img.shields.io/pypi/v/reqly?color=06b6d4&label=reqly)](https://pypi.org/project/reqly/)
+[![Python](https://img.shields.io/pypi/pyversions/reqly?color=06b6d4)](https://pypi.org/project/reqly/)
+[![License: GPL v3](https://img.shields.io/badge/license-GPL--3.0-06b6d4)](https://github.com/tanisheesh/reqly/blob/main/LICENSE)
+
+---
+
+## Install
+
+```bash
+pip install reqly
+```
+
+## Usage
+
+**FastAPI**
+
+```python
+import reqly
+from fastapi import FastAPI
+
+app = FastAPI()
+reqly.instrument(
+    app,
+    service_name="checkout-api",
+    collector_url="https://reqly.example.com",
+    api_key="your-ingest-key",
+)
+# Every route is now tracked: latency, errors, status codes, release
+```
+
+**Flask**
+
+```python
+import reqly
+from flask import Flask
+
+app = Flask(__name__)
+reqly.instrument(app, service_name="checkout-api")  # settings from REQLY_* env vars
+```
+
+**Starlette / Litestar** — same call:
+
+```python
+reqly.instrument(app, service_name="checkout-api")
+```
+
+**Django** (also Django REST Framework and Django Ninja) — Django has no app object, so add
+the middleware first in `MIDDLEWARE`:
+
+```python
+# settings.py
+MIDDLEWARE = [
+    "reqly.integrations.django.ReqlyMiddleware",
+    # ...
+]
+REQLY = {"service_name": "checkout-api", "api_key": "your-ingest-key"}  # optional
+```
+
+`instrument()` detects the framework by itself — no decorators, no middleware to wire up.
+Routes are recorded as templates in one style across frameworks: Django's
+`users/<int:pk>/` and DRF's `^users/(?P<pk>[^/.]+)/$` both become `/users/{pk}/`.
+The release you're running is picked up automatically from your CI or host
+(`GITHUB_SHA`, `RENDER_GIT_COMMIT`, `VERCEL_GIT_COMMIT_SHA`, …), so deploys show up in
+Reqly with no extra code.
+
+## What you get
+
+From the SDK, per request: method, **route template** (`/orders/{id}`, never the raw
+path), status code, duration, error type, host, **release**, environment and
+request/response **body size**.
+
+In the Reqly dashboard and collector:
+
+- **p50 / p95 / p99 latency** per route and per service — real percentiles from
+  mergeable sketches, not the max of per-route numbers
+- **Error rates, status codes and top routes** over 1h / 6h / 24h / 7d
+- **Deploy markers and per-release health** — each release's error rate and p95
+- **Hourly alerts** to Slack, Discord or a webhook when a route breaks from its usual
+  weekday-hour pattern, with **root-cause hints**
+- **Weekly AI report** — statistics find the anomalies, Groq (Llama 3.3-70b) writes the
+  summary; plain-text fallback without an API key
+
+An alert from the demo data looks like this:
+
+```
+🔴 Anomaly — flask-demo /orders (Friday 15:00-16:00 UTC, z=5.37)
+• error rate 30.0% vs 2.2% usual · p95 6588ms vs 1576ms usual
+• running release v2 — vs v1: errors 2.6% → 33.1%, p95 2072ms → 4501ms
+• 100% of errors came from host pod-3, which served 23% of requests
+```
+
+**Not on Python?** Node, Java, Go and .NET apps can report to the same collector through
+OpenTelemetry — no Reqly SDK needed. See the
+[OpenTelemetry guide](https://github.com/tanisheesh/reqly/blob/main/docs/OTEL.md).
+
+## Configuration
+
+Every option can be passed to `instrument()` or set as an environment variable.
+Resolution order: **argument → environment variable → default**.
+
+| argument | environment variable | default |
+|---|---|---|
+| `service_name` | `REQLY_SERVICE_NAME` | `sys.argv[0]` basename |
+| `collector_url` | `REQLY_COLLECTOR_URL` | `http://localhost:8000` |
+| `api_key` | `REQLY_API_KEY` | `None` |
+| `release` | `REQLY_RELEASE`, then CI variables (`GITHUB_SHA`, `CI_COMMIT_SHA`, `RENDER_GIT_COMMIT`, `VERCEL_GIT_COMMIT_SHA`, `RAILWAY_GIT_COMMIT_SHA`, `HEROKU_SLUG_COMMIT`, `K_REVISION`, …) | auto-detected, else `None` |
+| `environment` | `REQLY_ENVIRONMENT` | `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` (not implemented yet) |
+
+With `sample_rate` below 1.0, request counts in the dashboard are the sampled volume;
+latency percentiles and error rates stay unbiased.
+
+## Design guarantees
+
+**Fail-open** — any internal SDK error is caught and logged once; instrumentation disables
+itself rather than raise into your app. A slow or unreachable collector never blocks
+request threads — shipping happens on a background thread with strict HTTP timeouts.
+
+**Bounded cardinality** — routes are recorded as the framework's matched template
+(`/users/{id}`), never the raw path (`/users/123`). Unmatched paths (404s, scanners)
+collapse into a single `__unmatched__` bucket.
+
+**Bounded memory** — events wait in a fixed-size in-memory queue; under backpressure the
+oldest events are dropped and counted instead of growing without limit.
+
+**Safe retries** — batches are retried with exponential backoff on `408`, `429` and any
+`5xx` (for example a collector restart behind a proxy); other `4xx` responses are dropped
+immediately. Every event carries a unique `event_id` the collector deduplicates on, so a
+retry never double-counts.
+
+**Pre-fork servers** — under gunicorn `--preload` (or uWSGI without lazy-apps) each
+forked worker restarts its own flush thread and HTTP connection pool, so workers' events
+are shipped instead of silently queuing forever.
+
+## Compatibility
+
+| | Supported |
+|---|---|
+| Python | 3.9 – 3.13 |
+| FastAPI | 0.100+ (including routes in `app.mount()`ed sub-apps) |
+| Starlette | 0.27+ (including `Mount`) |
+| Litestar | 2.0+ |
+| Flask | 2.3+ |
+| Django | 4.2+, sync and async views; DRF and Django Ninja |
+| Collector | any version; `release`, `environment` and body sizes are stored by collector 0.3.0+ and ignored by older ones |
+
+## Self-hosting the collector
+
+The SDK sends data to a Reqly collector you run. The full stack — collector,
+TimescaleDB and dashboard — starts with Docker Compose:
+
+```bash
+git clone https://github.com/tanisheesh/reqly.git
+cd reqly
+docker compose up -d
+```
+
+Setup, configuration and AWS deployment:
+[docs/SETUP.md](https://github.com/tanisheesh/reqly/blob/main/docs/SETUP.md) ·
+[infra/DEPLOY.md](https://github.com/tanisheesh/reqly/blob/main/infra/DEPLOY.md) ·
+[ingest API spec](https://github.com/tanisheesh/reqly/blob/main/docs/INGEST_SPEC.md)
+
+## Live demo
+
+Reqly monitors [EventFlow](https://eventflow-g2h5.onrender.com), a Flask event management
+app, in production:
+
+- **Demo app** → [eventflow-g2h5.onrender.com](https://eventflow-g2h5.onrender.com)
+- **Metrics dashboard** → [reqly-eventflow-dashboard.onrender.com](https://reqly-eventflow-dashboard.onrender.com)
+
+> Log in as **Administrator** (`admin@eventhub.com` / `Admin@123`) → click **Metrics** in the nav.
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/tanisheesh/reqly/blob/main/sdk/CHANGELOG.md).
+
+## License
+
+GPL-3.0-or-later — see [LICENSE](https://github.com/tanisheesh/reqly/blob/main/LICENSE).

reqly-0.3.0/README.md

@@ -0,0 +1,191 @@
+# reqly
+
+**Self-hosted API monitoring for FastAPI, Flask, Django, Starlette and Litestar — two lines of code.**
+Latency percentiles, error rates and release tracking for every route, shipped to your own
+[Reqly](https://github.com/tanisheesh/reqly) collector — which turns them into deploy-aware
+hourly alerts and weekly AI anomaly reports.
+
+[![PyPI](https://img.shields.io/pypi/v/reqly?color=06b6d4&label=reqly)](https://pypi.org/project/reqly/)
+[![Python](https://img.shields.io/pypi/pyversions/reqly?color=06b6d4)](https://pypi.org/project/reqly/)
+[![License: GPL v3](https://img.shields.io/badge/license-GPL--3.0-06b6d4)](https://github.com/tanisheesh/reqly/blob/main/LICENSE)
+
+---
+
+## Install
+
+```bash
+pip install reqly
+```
+
+## Usage
+
+**FastAPI**
+
+```python
+import reqly
+from fastapi import FastAPI
+
+app = FastAPI()
+reqly.instrument(
+    app,
+    service_name="checkout-api",
+    collector_url="https://reqly.example.com",
+    api_key="your-ingest-key",
+)
+# Every route is now tracked: latency, errors, status codes, release
+```
+
+**Flask**
+
+```python
+import reqly
+from flask import Flask
+
+app = Flask(__name__)
+reqly.instrument(app, service_name="checkout-api")  # settings from REQLY_* env vars
+```
+
+**Starlette / Litestar** — same call:
+
+```python
+reqly.instrument(app, service_name="checkout-api")
+```
+
+**Django** (also Django REST Framework and Django Ninja) — Django has no app object, so add
+the middleware first in `MIDDLEWARE`:
+
+```python
+# settings.py
+MIDDLEWARE = [
+    "reqly.integrations.django.ReqlyMiddleware",
+    # ...
+]
+REQLY = {"service_name": "checkout-api", "api_key": "your-ingest-key"}  # optional
+```
+
+`instrument()` detects the framework by itself — no decorators, no middleware to wire up.
+Routes are recorded as templates in one style across frameworks: Django's
+`users/<int:pk>/` and DRF's `^users/(?P<pk>[^/.]+)/$` both become `/users/{pk}/`.
+The release you're running is picked up automatically from your CI or host
+(`GITHUB_SHA`, `RENDER_GIT_COMMIT`, `VERCEL_GIT_COMMIT_SHA`, …), so deploys show up in
+Reqly with no extra code.
+
+## What you get
+
+From the SDK, per request: method, **route template** (`/orders/{id}`, never the raw
+path), status code, duration, error type, host, **release**, environment and
+request/response **body size**.
+
+In the Reqly dashboard and collector:
+
+- **p50 / p95 / p99 latency** per route and per service — real percentiles from
+  mergeable sketches, not the max of per-route numbers
+- **Error rates, status codes and top routes** over 1h / 6h / 24h / 7d
+- **Deploy markers and per-release health** — each release's error rate and p95
+- **Hourly alerts** to Slack, Discord or a webhook when a route breaks from its usual
+  weekday-hour pattern, with **root-cause hints**
+- **Weekly AI report** — statistics find the anomalies, Groq (Llama 3.3-70b) writes the
+  summary; plain-text fallback without an API key
+
+An alert from the demo data looks like this:
+
+```
+🔴 Anomaly — flask-demo /orders (Friday 15:00-16:00 UTC, z=5.37)
+• error rate 30.0% vs 2.2% usual · p95 6588ms vs 1576ms usual
+• running release v2 — vs v1: errors 2.6% → 33.1%, p95 2072ms → 4501ms
+• 100% of errors came from host pod-3, which served 23% of requests
+```
+
+**Not on Python?** Node, Java, Go and .NET apps can report to the same collector through
+OpenTelemetry — no Reqly SDK needed. See the
+[OpenTelemetry guide](https://github.com/tanisheesh/reqly/blob/main/docs/OTEL.md).
+
+## Configuration
+
+Every option can be passed to `instrument()` or set as an environment variable.
+Resolution order: **argument → environment variable → default**.
+
+| argument | environment variable | default |
+|---|---|---|
+| `service_name` | `REQLY_SERVICE_NAME` | `sys.argv[0]` basename |
+| `collector_url` | `REQLY_COLLECTOR_URL` | `http://localhost:8000` |
+| `api_key` | `REQLY_API_KEY` | `None` |
+| `release` | `REQLY_RELEASE`, then CI variables (`GITHUB_SHA`, `CI_COMMIT_SHA`, `RENDER_GIT_COMMIT`, `VERCEL_GIT_COMMIT_SHA`, `RAILWAY_GIT_COMMIT_SHA`, `HEROKU_SLUG_COMMIT`, `K_REVISION`, …) | auto-detected, else `None` |
+| `environment` | `REQLY_ENVIRONMENT` | `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` (not implemented yet) |
+
+With `sample_rate` below 1.0, request counts in the dashboard are the sampled volume;
+latency percentiles and error rates stay unbiased.
+
+## Design guarantees
+
+**Fail-open** — any internal SDK error is caught and logged once; instrumentation disables
+itself rather than raise into your app. A slow or unreachable collector never blocks
+request threads — shipping happens on a background thread with strict HTTP timeouts.
+
+**Bounded cardinality** — routes are recorded as the framework's matched template
+(`/users/{id}`), never the raw path (`/users/123`). Unmatched paths (404s, scanners)
+collapse into a single `__unmatched__` bucket.
+
+**Bounded memory** — events wait in a fixed-size in-memory queue; under backpressure the
+oldest events are dropped and counted instead of growing without limit.
+
+**Safe retries** — batches are retried with exponential backoff on `408`, `429` and any
+`5xx` (for example a collector restart behind a proxy); other `4xx` responses are dropped
+immediately. Every event carries a unique `event_id` the collector deduplicates on, so a
+retry never double-counts.
+
+**Pre-fork servers** — under gunicorn `--preload` (or uWSGI without lazy-apps) each
+forked worker restarts its own flush thread and HTTP connection pool, so workers' events
+are shipped instead of silently queuing forever.
+
+## Compatibility
+
+| | Supported |
+|---|---|
+| Python | 3.9 – 3.13 |
+| FastAPI | 0.100+ (including routes in `app.mount()`ed sub-apps) |
+| Starlette | 0.27+ (including `Mount`) |
+| Litestar | 2.0+ |
+| Flask | 2.3+ |
+| Django | 4.2+, sync and async views; DRF and Django Ninja |
+| Collector | any version; `release`, `environment` and body sizes are stored by collector 0.3.0+ and ignored by older ones |
+
+## Self-hosting the collector
+
+The SDK sends data to a Reqly collector you run. The full stack — collector,
+TimescaleDB and dashboard — starts with Docker Compose:
+
+```bash
+git clone https://github.com/tanisheesh/reqly.git
+cd reqly
+docker compose up -d
+```
+
+Setup, configuration and AWS deployment:
+[docs/SETUP.md](https://github.com/tanisheesh/reqly/blob/main/docs/SETUP.md) ·
+[infra/DEPLOY.md](https://github.com/tanisheesh/reqly/blob/main/infra/DEPLOY.md) ·
+[ingest API spec](https://github.com/tanisheesh/reqly/blob/main/docs/INGEST_SPEC.md)
+
+## Live demo
+
+Reqly monitors [EventFlow](https://eventflow-g2h5.onrender.com), a Flask event management
+app, in production:
+
+- **Demo app** → [eventflow-g2h5.onrender.com](https://eventflow-g2h5.onrender.com)
+- **Metrics dashboard** → [reqly-eventflow-dashboard.onrender.com](https://reqly-eventflow-dashboard.onrender.com)
+
+> Log in as **Administrator** (`admin@eventhub.com` / `Admin@123`) → click **Metrics** in the nav.
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/tanisheesh/reqly/blob/main/sdk/CHANGELOG.md).
+
+## License
+
+GPL-3.0-or-later — see [LICENSE](https://github.com/tanisheesh/reqly/blob/main/LICENSE).

{reqly-0.1.4 → reqly-0.3.0}/pyproject.toml

@@ -4,15 +4,17 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reqly"
-version = "0.1.4"
-description = "Auto-instrumentation SDK for FastAPI and Flask: zero-code latency, error rates, and status codes shipped to a Reqly collector."
+version = "0.3.0"
+description = "Self-hosted API monitoring for FastAPI, Flask, Django, Starlette and Litestar in two lines: latency percentiles, error rates and release tracking per route, with deploy-aware alerts and weekly AI anomaly reports."
 readme = "README.md"
 requires-python = ">=3.9"
 license = "GPL-3.0-or-later"
-authors = [{ name = "reqly" }]
+authors = [{ name = "Tanish Poddar" }]
 keywords = [
-    "observability", "apm", "monitoring", "fastapi", "flask",
-    "telemetry", "metrics", "latency", "tracing"
+    "observability", "apm", "monitoring", "fastapi", "flask", "django",
+    "starlette", "litestar", "telemetry",
+    "metrics", "latency", "percentiles", "alerting", "anomaly-detection",
+    "release-tracking", "self-hosted", "timescaledb"
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -22,8 +24,10 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: System :: Monitoring",
+    "Framework :: Django",
     "Framework :: FastAPI",
     "Framework :: Flask",
 ]
@@ -32,19 +36,25 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://reqly-sdk.vercel.app/"
+Homepage = "https://reqly.tanisheesh.in"
 Repository = "https://github.com/tanisheesh/reqly"
 Issues = "https://github.com/tanisheesh/reqly/issues"
-Documentation = "https://github.com/tanisheesh/reqly/blob/main/CONTRIBUTING.md"
-"Live Demo" = "https://eventflow-g2h5.onrender.com"
+Documentation = "https://github.com/tanisheesh/reqly/blob/main/docs/SETUP.md"
+Changelog = "https://github.com/tanisheesh/reqly/blob/main/sdk/CHANGELOG.md"
+"Live Demo" = "https://reqly-eventflow-dashboard.onrender.com"
 
 [project.optional-dependencies]
 fastapi = ["fastapi>=0.100"]
+starlette = ["starlette>=0.27"]
+litestar = ["litestar>=2.0"]
 flask = ["flask>=2.3"]
+django = ["django>=4.2"]
 dev = [
     "pytest>=8.0",
     "fastapi>=0.100",
+    "litestar>=2.0",
     "flask>=2.3",
+    "django>=4.2",
     "httpx>=0.27",
 ]
 

{reqly-0.1.4 → reqly-0.3.0}/reqly/__init__.py

@@ -1,40 +1,40 @@
 from __future__ import annotations
 
 import logging
-from importlib.metadata import PackageNotFoundError
-from importlib.metadata import version as _pkg_version
 
 from .core.client import ReqlyClient
-from .core.config import Config
+from .core.config import Config, _get_sdk_version
 
-try:
-    __version__ = _pkg_version("reqly")
-except PackageNotFoundError:
-    __version__ = "0.1.3"
+__version__ = _get_sdk_version()
 
 __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] = {}
+# id(app) -> (app, client) for every instrumented app. Holding the app
+# itself keeps its id from being reused by a new object, so a repeat
+# instrument() call on the same app is recognized reliably -- without
+# setting attributes on the app (Litestar apps use __slots__ and refuse).
+_CLIENTS: dict[int, tuple[object, 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"
+    # Walk the class hierarchy so subclasses of an app class (a project's
+    # own `class App(FastAPI)`) are recognized too. FastAPI subclasses
+    # Starlette, so it must be checked first.
+    modules = [cls.__module__ or "" for cls in type(app).__mro__]
+    for framework in ("fastapi", "litestar", "starlette", "flask"):
+        if any(m == framework or m.startswith(framework + ".") for m in modules):
+            return framework
+    # Fallback to duck typing if the module names aren't conclusive.
+    if hasattr(app, "add_middleware") and hasattr(app, "router"):
+        return "starlette"
     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."
+        f"{type(app)!r}. Supported: FastAPI, Starlette, Litestar, Flask "
+        "(Django: add reqly.integrations.django.ReqlyMiddleware to MIDDLEWARE)."
     )
 
 
@@ -50,8 +50,11 @@ def instrument(
     max_queue_size: int | None = None,
     ignore_routes: list[str] | None = None,
     capture_request_body: bool | None = None,
+    release: str | None = None,
+    environment: str | None = None,
 ) -> ReqlyClient | None:
-    """Instrument a FastAPI or Flask app with one line.
+    """Instrument a FastAPI, Starlette, Litestar or Flask app with one line.
+    (Django: add ``reqly.integrations.django.ReqlyMiddleware`` to MIDDLEWARE.)
 
     Config resolution order for any omitted argument: explicit kwarg >
     environment variable (REQLY_*) > default. See core.config.Config
@@ -62,6 +65,14 @@ def instrument(
     rather than raising, so adding Reqly can never be the reason an
     app fails to start.
     """
+    entry = _CLIENTS.get(id(app))
+    existing = entry[1] if entry is not None and entry[0] is app else None
+    if existing is not None:
+        # A second call would add a second middleware and a second flush
+        # thread, double-counting every request.
+        logger.warning("reqly: app is already instrumented, ignoring repeat instrument() call")
+        return existing
+
     try:
         framework = _detect_framework(app)
         config = Config.resolve(
@@ -74,6 +85,8 @@ def instrument(
             max_queue_size=max_queue_size,
             ignore_routes=ignore_routes,
             capture_request_body=capture_request_body,
+            release=release,
+            environment=environment,
         )
         client = ReqlyClient(config)
 
@@ -87,12 +100,20 @@ def instrument(
             from .integrations.fastapi import instrument_fastapi
 
             instrument_fastapi(app, client)
+        elif framework == "starlette":
+            from .integrations.starlette import instrument_starlette
+
+            instrument_starlette(app, client)
+        elif framework == "litestar":
+            from .integrations.litestar import instrument_litestar
+
+            instrument_litestar(app, client)
         else:
             from .integrations.flask import instrument_flask
 
             instrument_flask(app, client)
 
-        _CLIENTS[id(app)] = client
+        _CLIENTS[id(app)] = (app, client)
         return client
     except Exception:
         logger.warning(

{reqly-0.1.4 → reqly-0.3.0}/reqly/core/buffer.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import atexit
 import logging
+import os
 import threading
 import time
 from collections import deque
@@ -40,11 +41,31 @@ class EventBuffer:
         self._dropped_events = 0
 
         self._stop_event = threading.Event()
+        self._start_thread()
+        atexit.register(self.shutdown)
+        # Pre-fork servers (gunicorn --preload, uWSGI without lazy-apps)
+        # import the app -- and start this thread -- in the master, then
+        # fork workers. Threads don't survive fork, so without this hook every
+        # worker would queue events forever and never ship them.
+        if hasattr(os, "register_at_fork"):
+            os.register_at_fork(after_in_child=self._reinit_after_fork)
+
+    def _start_thread(self) -> None:
         self._thread = threading.Thread(
             target=self._run, name="reqly-flush", daemon=True
         )
         self._thread.start()
-        atexit.register(self.shutdown)
+
+    def _reinit_after_fork(self) -> None:
+        if self._stop_event.is_set():
+            return
+        # The parent may have held the lock mid-fork; a fresh one is safe
+        # because the child is single-threaded at this point. Events queued
+        # before the fork belong to the parent, which ships them itself.
+        self._lock = threading.Lock()
+        self._queue.clear()
+        self._shipper.reset_after_fork()
+        self._start_thread()
 
     def add(self, event: RequestEvent) -> None:
         with self._lock: