reqly 0.1.4__tar.gz → 0.2.0__tar.gz

reqly-0.2.0/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: reqly
+Version: 0.2.0
+Summary: Self-hosted API monitoring for FastAPI and Flask 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,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 :: 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
+
+**Self-hosted API monitoring for FastAPI and Flask — 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
+```
+
+`instrument()` detects FastAPI or Flask by itself — no decorators, no middleware to wire up.
+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+ |
+| Flask | 2.3+ |
+| 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.2.0/README.md

@@ -0,0 +1,168 @@
+# reqly
+
+**Self-hosted API monitoring for FastAPI and Flask — 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
+```
+
+`instrument()` detects FastAPI or Flask by itself — no decorators, no middleware to wire up.
+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+ |
+| Flask | 2.3+ |
+| 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.2.0}/pyproject.toml

@@ -4,15 +4,16 @@ 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.2.0"
+description = "Self-hosted API monitoring for FastAPI and Flask 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", "telemetry",
+    "metrics", "latency", "percentiles", "alerting", "anomaly-detection",
+    "release-tracking", "self-hosted", "timescaledb"
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -22,6 +23,7 @@ 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 :: FastAPI",
@@ -32,11 +34,12 @@ 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"]

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

@@ -1,16 +1,11 @@
 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"]
 
@@ -19,6 +14,7 @@ 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] = {}
+_APP_CLIENT_ATTR = "_reqly_client"
 
 
 def _detect_framework(app) -> str:
@@ -50,6 +46,8 @@ 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.
 
@@ -62,6 +60,15 @@ def instrument(
     rather than raising, so adding Reqly can never be the reason an
     app fails to start.
     """
+    # Marked on the app object itself: keying on id(app) alone would match a
+    # new app that happens to reuse a garbage-collected app's id.
+    existing = getattr(app, _APP_CLIENT_ATTR, 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 +81,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)
 
@@ -93,6 +102,7 @@ def instrument(
             instrument_flask(app, client)
 
         _CLIENTS[id(app)] = client
+        setattr(app, _APP_CLIENT_ATTR, client)
         return client
     except Exception:
         logger.warning(

{reqly-0.1.4 → reqly-0.2.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:

{reqly-0.1.4 → reqly-0.2.0}/reqly/core/capture.py

@@ -4,14 +4,8 @@ import socket
 import uuid
 from dataclasses import asdict, dataclass, field
 from datetime import datetime, timezone
-from importlib.metadata import PackageNotFoundError, version as _pkg_version
 
-
-def _get_sdk_version() -> str:
-    try:
-        return _pkg_version("reqly")
-    except PackageNotFoundError:
-        return "0.1.0"
+from .config import _get_sdk_version
 
 _HOSTNAME = socket.gethostname()
 
@@ -35,6 +29,8 @@ class RequestEvent:
     error: bool = False
     error_type: str | None = None
     host: str = _HOSTNAME
+    request_bytes: int | None = None
+    response_bytes: int | None = None
     sdk_version: str = field(default_factory=_get_sdk_version)
 
     def to_dict(self) -> dict:
@@ -61,6 +57,8 @@ def build_event(
     error: bool,
     error_type: str | None,
     sdk_version: str,
+    request_bytes: int | None = None,
+    response_bytes: int | None = None,
 ) -> RequestEvent:
     return RequestEvent(
         service_name=service_name,
@@ -71,4 +69,6 @@ def build_event(
         error=error,
         error_type=error_type,
         sdk_version=sdk_version,
+        request_bytes=request_bytes,
+        response_bytes=response_bytes,
     )

{reqly-0.1.4 → reqly-0.2.0}/reqly/core/client.py

@@ -34,6 +34,8 @@ class ReqlyClient:
                 api_key=config.api_key,
                 service_name=config.service_name,
                 sdk_version=config.sdk_version,
+                release=config.release,
+                environment=config.environment,
             )
             self._buffer = EventBuffer(
                 shipper=shipper,
@@ -57,6 +59,8 @@ class ReqlyClient:
         duration_ms: float,
         error: bool,
         error_type: str | None,
+        request_bytes: int | None = None,
+        response_bytes: int | None = None,
     ) -> None:
         if self._disabled:
             return
@@ -74,6 +78,8 @@ class ReqlyClient:
                 error=error,
                 error_type=error_type,
                 sdk_version=self.config.sdk_version,
+                request_bytes=request_bytes,
+                response_bytes=response_bytes,
             )
             self._buffer.add(event)
         except Exception:

{reqly-0.1.4 → reqly-0.2.0}/reqly/core/config.py

@@ -6,10 +6,13 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 
 
 def _get_sdk_version() -> str:
+    """Single source of truth for the SDK version: the installed package
+    metadata. A source checkout that was never pip-installed has none, and
+    reports that honestly rather than a hardcoded number that goes stale."""
     try:
         return _pkg_version("reqly")
     except PackageNotFoundError:
-        return "0.1.0"
+        return "0.0.0+unknown"
 
 
 def _env_float(name: str, default: float) -> float:
@@ -39,6 +42,31 @@ def _env_bool(name: str, default: bool) -> bool:
     return raw.strip().lower() in ("1", "true", "yes", "on")
 
 
+# Commit SHA variables set by common CI/CD and hosting platforms, checked in
+# order when neither release= nor REQLY_RELEASE is given.
+_RELEASE_ENV_VARS = (
+    "GIT_COMMIT",  # Jenkins and many custom pipelines
+    "GITHUB_SHA",  # GitHub Actions
+    "CI_COMMIT_SHA",  # GitLab CI
+    "RENDER_GIT_COMMIT",  # Render
+    "VERCEL_GIT_COMMIT_SHA",  # Vercel
+    "RAILWAY_GIT_COMMIT_SHA",  # Railway
+    "HEROKU_SLUG_COMMIT",  # Heroku (dyno metadata)
+    "SOURCE_VERSION",  # Heroku buildpacks
+    "K_REVISION",  # Cloud Run / Knative revision name
+)
+_MAX_RELEASE_LEN = 128
+_MAX_ENVIRONMENT_LEN = 32
+
+
+def _detect_release() -> str | None:
+    for name in ("REQLY_RELEASE",) + _RELEASE_ENV_VARS:
+        value = (os.environ.get(name) or "").strip()
+        if value:
+            return value[:_MAX_RELEASE_LEN]
+    return None
+
+
 @dataclass
 class Config:
     """Resolved configuration for an instrumented app.
@@ -56,6 +84,8 @@ class Config:
     max_queue_size: int = 2000
     ignore_routes: list[str] = field(default_factory=lambda: ["/health", "/metrics"])
     capture_request_body: bool = False
+    release: str | None = None
+    environment: str | None = None
     sdk_version: str = field(default_factory=_get_sdk_version)
 
     @classmethod
@@ -70,6 +100,8 @@ class Config:
         max_queue_size: int | None,
         ignore_routes: list[str] | None,
         capture_request_body: bool | None,
+        release: str | None = None,
+        environment: str | None = None,
     ) -> "Config":
         import sys as _sys
 
@@ -111,11 +143,22 @@ class Config:
             ignore_routes=(
                 ignore_routes
                 if ignore_routes is not None
-                else (os.environ.get("REQLY_IGNORE_ROUTES", "/health,/metrics").split(","))
+                else [
+                    r.strip()
+                    for r in os.environ.get("REQLY_IGNORE_ROUTES", "/health,/metrics").split(",")
+                    if r.strip()
+                ]
             ),
             capture_request_body=(
                 capture_request_body
                 if capture_request_body is not None
                 else _env_bool("REQLY_CAPTURE_REQUEST_BODY", False)
             ),
+            release=(release[:_MAX_RELEASE_LEN] if release else _detect_release()),
+            environment=(
+                (environment or os.environ.get("REQLY_ENVIRONMENT") or "").strip()[
+                    :_MAX_ENVIRONMENT_LEN
+                ]
+                or None
+            ),
         )