reqly 0.5.0__tar.gz → 0.5.1__tar.gz

{reqly-0.5.0 → reqly-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reqly
-Version: 0.5.0
+Version: 0.5.1
 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

{reqly-0.5.0 → reqly-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reqly"
-version = "0.5.0"
+version = "0.5.1"
 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"

{reqly-0.5.0 → reqly-0.5.1}/reqly/integrations/fastapi.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import time
 from typing import Callable, Optional
 
@@ -7,6 +8,8 @@ from ..core.capture import normalize_route
 from ..core.client import ReqlyClient
 from ..core.request_context import RequestInfo, begin_request, end_request
 
+logger = logging.getLogger("reqly")
+
 RouteResolver = Callable[[dict], Optional[str]]
 
 
@@ -104,22 +107,38 @@ class ReqlyASGIMiddleware:
         finally:
             duration_ms = (time.perf_counter() - start) * 1000
             llm = end_request(usage_token)
-            route_template = route_template_from_scope(scope, entry_root_path)
-            if route_template is None and self._route_resolver is not None:
+            try:
+                self._record(scope, original_scope, entry_root_path, status_code, duration_ms,
+                             error, error_type, request_bytes, response_bytes, llm)
+            except Exception:
+                # Fail-open: a broken route_resolver (user code with
+                # instrument_asgi) or anything else here must never reach
+                # the app -- the response has usually been sent already.
+                logger.warning("reqly: could not record ASGI request", exc_info=True)
+
+    def _record(self, scope, original_scope, entry_root_path, status_code, duration_ms,
+                error, error_type, request_bytes, response_bytes, llm) -> None:
+        route_template = route_template_from_scope(scope, entry_root_path)
+        if route_template is None and self._route_resolver is not None:
+            try:
                 route_template = self._route_resolver(original_scope)
-            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,
-                request_bytes=request_bytes,
-                response_bytes=response_bytes,
-                request_info=lambda: asgi_request_info(scope),
-                llm=llm,
-            )
+            except Exception:
+                # Same as the WSGI wrapper: a failing resolver means "no
+                # route", not a lost event and not an error in the app.
+                logger.debug("reqly: route_resolver failed", exc_info=True)
+        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,
+            request_bytes=request_bytes,
+            response_bytes=response_bytes,
+            request_info=lambda: asgi_request_info(scope),
+            llm=llm,
+        )
 
 
 def instrument_fastapi(app, client: ReqlyClient) -> None:

reqly-0.5.1/reqly/integrations/flask.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import logging
+import time
+
+from ..core.capture import normalize_route
+from ..core.client import ReqlyClient
+from ..core.request_context import RequestInfo, begin_request, end_request
+
+logger = logging.getLogger("reqly")
+
+_START_TIME_ATTR = "_REQLY_start_time"
+_USAGE_TOKEN_ATTR = "_REQLY_usage_token"
+
+
+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())
+        setattr(g, _USAGE_TOKEN_ATTR, begin_request())
+
+    @app.teardown_request
+    def _REQLY_teardown_request(exc):
+        start = getattr(g, _START_TIME_ATTR, None)
+        if start is None:
+            return
+        try:
+            duration_ms = (time.perf_counter() - start) * 1000
+            llm = end_request(getattr(g, _USAGE_TOKEN_ATTR, None))
+
+            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,
+                # Content-Length based: Flask can't count a streamed body without
+                # consuming it, so chunked requests/streamed responses report None.
+                request_bytes=request.content_length,
+                response_bytes=getattr(g, "_REQLY_response_bytes", None),
+                request_info=lambda: RequestInfo(
+                    method=request.method,
+                    path=request.path,
+                    headers={k.lower(): v for k, v in request.headers.items()},
+                    raw=request,
+                ),
+                llm=llm,
+            )
+        except Exception:
+            # Fail-open: nothing here may turn into an error in the app.
+            logger.debug("reqly: could not record Flask request", exc_info=True)
+
+    @app.after_request
+    def _REQLY_after_request(response):
+        g._REQLY_response_status = response.status_code
+        g._REQLY_response_bytes = None if response.is_streamed else response.content_length
+        return response

{reqly-0.5.0 → reqly-0.5.1}/reqly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reqly
-Version: 0.5.0
+Version: 0.5.1
 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

{reqly-0.5.0 → reqly-0.5.1}/tests/test_consumers_llm_wsgi.py

@@ -237,3 +237,23 @@ def test_instrument_asgi(fake_collector):
     [event] = _events(app.client, batches)
     assert (event["route"], event["status_code"], event["response_bytes"]) == ("/things", 201, 7)
     app.client.shutdown()
+
+
+def test_a_failing_route_resolver_never_reaches_the_app(fake_collector):
+    url, batches = fake_collector
+
+    async def raw_asgi(scope, receive, send):
+        await send({"type": "http.response.start", "status": 200, "headers": []})
+        await send({"type": "http.response.body", "body": b"ok"})
+
+    def broken(scope):
+        raise KeyError("route")
+
+    app = reqly.instrument_asgi(raw_asgi, service_name="a", collector_url=url, flush_interval_seconds=999,
+                                route_resolver=broken)
+    from starlette.testclient import TestClient as ASGIClient
+
+    assert ASGIClient(app).get("/x").text == "ok"
+    [event] = _events(app.client, batches)
+    assert event["route"] == "__unmatched__"  # recorded, without a route
+    app.client.shutdown()

reqly-0.5.0/reqly/integrations/flask.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-import time
-
-from ..core.capture import normalize_route
-from ..core.client import ReqlyClient
-from ..core.request_context import RequestInfo, begin_request, end_request
-
-_START_TIME_ATTR = "_REQLY_start_time"
-_USAGE_TOKEN_ATTR = "_REQLY_usage_token"
-
-
-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())
-        setattr(g, _USAGE_TOKEN_ATTR, begin_request())
-
-    @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
-        llm = end_request(getattr(g, _USAGE_TOKEN_ATTR, None))
-
-        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,
-            # Content-Length based: Flask can't count a streamed body without
-            # consuming it, so chunked requests/streamed responses report None.
-            request_bytes=request.content_length,
-            response_bytes=getattr(g, "_REQLY_response_bytes", None),
-            request_info=lambda: RequestInfo(
-                method=request.method,
-                path=request.path,
-                headers={k.lower(): v for k, v in request.headers.items()},
-                raw=request,
-            ),
-            llm=llm,
-        )
-
-    @app.after_request
-    def _REQLY_after_request(response):
-        g._REQLY_response_status = response.status_code
-        g._REQLY_response_bytes = None if response.is_streamed else response.content_length
-        return response