tinymonpy 0.2.0__tar.gz → 0.3.0__tar.gz

{tinymonpy-0.2.0 → tinymonpy-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinymonpy
-Version: 0.2.0
+Version: 0.3.0
 Summary: Tiny error monitoring SDK for Python.
 Author: tinymon
 License: MIT

{tinymonpy-0.2.0 → tinymonpy-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tinymonpy"
-version = "0.2.0"
+version = "0.3.0"
 description = "Tiny error monitoring SDK for Python."
 requires-python = ">=3.8"
 license = { text = "MIT" }

{tinymonpy-0.2.0 → tinymonpy-0.3.0}/tinymonpy/__init__.py

@@ -26,6 +26,7 @@ from .stacktrace import parse_traceback as _parse_traceback  # public for contra
 __all__ = [
     "init",
     "capture_exception",
+    "capture_exception_with_context",
     "capture_message",
     "set_user",
     "set_tag",
@@ -34,7 +35,7 @@ __all__ = [
     "_parse_traceback",
 ]
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 _client: Optional[Client] = None
 
@@ -72,6 +73,21 @@ def capture_exception(exc: BaseException) -> None:
         _client.capture_exception(exc)
 
 
+def capture_exception_with_context(
+    exc: BaseException,
+    *,
+    request: Optional[Dict[str, Any]] = None,
+    user: Optional[Dict[str, Any]] = None,
+    tags: Optional[Dict[str, str]] = None,
+) -> None:
+    """Per-event context capture. Use from middleware; do NOT use set_user/
+    set_tag for per-request data — they race under concurrency."""
+    if _client is not None:
+        _client.capture_exception_with_context(
+            exc, request=request, user=user, tags=tags
+        )
+
+
 def capture_message(msg: str, level: str = "info") -> None:
     if _client is not None:
         _client.capture_message(msg, level)

{tinymonpy-0.2.0 → tinymonpy-0.3.0}/tinymonpy/client.py

@@ -40,15 +40,21 @@ class Client:
         self.send_default_pii = send_default_pii
         self.transport = Transport(self.endpoint, dsn)
 
-    def _prepare(self, exc: BaseException) -> Optional[Dict[str, Any]]:
+    def _prepare(
+        self,
+        exc: BaseException,
+        ctx: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Dict[str, Any]]:
         snap = scope.snapshot()
+        ctx = ctx or {}
         event = build_event(
             exc,
             release=self.release,
             environment=self.environment,
-            user=snap["user"],
-            tags=snap["tags"],
+            user=ctx.get("user") or snap["user"],
+            tags=ctx.get("tags") or snap["tags"],
             breadcrumbs=snap["breadcrumbs"],
+            request=ctx.get("request"),
         )
         # Default scrub BEFORE before_send.
         scrub_event(
@@ -77,6 +83,29 @@ class Client:
             # SWALLOW. The SDK must never throw into the host app.
             pass
 
+    def capture_exception_with_context(
+        self,
+        exc: BaseException,
+        *,
+        request: Optional[Dict[str, Any]] = None,
+        user: Optional[Dict[str, Any]] = None,
+        tags: Optional[Dict[str, str]] = None,
+    ) -> None:
+        """Capture with per-event context. Framework middleware uses this so
+        request data is attached to THIS event without touching global scope —
+        safe under concurrent requests."""
+        try:
+            if random.random() > self.sample_rate:
+                return
+            event = self._prepare(
+                exc, {"request": request, "user": user, "tags": tags}
+            )
+            if event is None:
+                return
+            self.transport.enqueue(event)
+        except Exception:
+            pass
+
     def capture_message(self, message: str, level: str = "info") -> None:
         try:
             event = self._prepare(Exception(message))

{tinymonpy-0.2.0 → tinymonpy-0.3.0}/tinymonpy/event_builder.py

@@ -28,6 +28,7 @@ def build_event(
     tags: Optional[Dict[str, str]] = None,
     breadcrumbs: Optional[List[Dict[str, Any]]] = None,
     url: Optional[str] = None,
+    request: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
     event: Dict[str, Any] = {
         "event_id": str(_uuid.uuid4()),
@@ -48,7 +49,13 @@ def build_event(
         event["release"] = release
     if environment is not None:
         event["environment"] = environment
-    if url is not None:
+    # `request` (full dict with method+url) takes precedence over the legacy
+    # `url` kwarg used by the browser SDK.
+    if request:
+        event["request"] = {
+            k: v for k, v in request.items() if k in ("method", "url") and v
+        }
+    elif url is not None:
         event["request"] = {"url": url}
     return event
 

tinymonpy-0.3.0/tinymonpy/frameworks/__init__.py

@@ -0,0 +1,3 @@
+"""Optional framework integrations. Importing this package does NOT pull in
+any framework-specific runtime dependency — each submodule only needs the
+stdlib + tinymonpy itself."""

tinymonpy-0.3.0/tinymonpy/frameworks/asgi.py

@@ -0,0 +1,73 @@
+"""ASGI middleware. Wraps any ASGI app (FastAPI, Starlette, Django ASGI).
+
+Usage with FastAPI::
+
+    from fastapi import FastAPI
+    import tinymonpy
+    from tinymonpy.frameworks.asgi import TinymonASGI
+
+    tinymonpy.init(dsn=os.environ["TINYMON_DSN"])
+    app = FastAPI()
+    app.add_middleware(TinymonASGI)
+
+Captures with per-event request context (method + URL from the scope) and
+re-raises so the framework's exception handlers still run.
+"""
+from __future__ import annotations
+
+from typing import Any, Awaitable, Callable, Iterable
+
+import tinymonpy as _tm
+
+Scope = dict
+Receive = Callable[[], Awaitable[dict]]
+Send = Callable[[dict], Awaitable[None]]
+
+
+def _url_from_scope(scope: Scope) -> str:
+    scheme = scope.get("scheme", "http")
+    headers: Iterable[tuple] = scope.get("headers") or []
+    host = ""
+    for k, v in headers:
+        if k == b"host":
+            host = v.decode("latin-1", errors="replace")
+            break
+    if not host:
+        srv = scope.get("server") or ()
+        host = f"{srv[0]}:{srv[1]}" if len(srv) >= 2 else ""
+    path = scope.get("raw_path") or scope.get("path", "")
+    if isinstance(path, bytes):
+        path = path.decode("latin-1", errors="replace")
+    qs = scope.get("query_string") or b""
+    if isinstance(qs, bytes):
+        qs = qs.decode("latin-1", errors="replace")
+    full = f"{path}?{qs}" if qs else path
+    return f"{scheme}://{host}{full}" if host else full
+
+
+class TinymonASGI:
+    """Wrap an ASGI app; capture exceptions, then re-raise."""
+
+    def __init__(self, app: Callable[[Scope, Receive, Send], Awaitable[None]]) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope.get("type") not in ("http", "websocket"):
+            await self.app(scope, receive, send)
+            return
+        try:
+            await self.app(scope, receive, send)
+        except BaseException as exc:
+            client = _tm._client  # type: ignore[attr-defined]
+            if client is not None:
+                try:
+                    client.capture_exception_with_context(
+                        exc,
+                        request={
+                            "method": scope.get("method"),
+                            "url": _url_from_scope(scope),
+                        },
+                    )
+                except Exception:
+                    pass
+            raise

tinymonpy-0.3.0/tinymonpy/frameworks/wsgi.py

@@ -0,0 +1,57 @@
+"""WSGI middleware. Wraps any WSGI app (Flask, Django sync, plain WSGI).
+
+Usage with Flask::
+
+    from flask import Flask
+    import tinymonpy
+    from tinymonpy.frameworks.wsgi import TinymonWSGI
+
+    tinymonpy.init(dsn=os.environ["TINYMON_DSN"])
+    app = Flask(__name__)
+    app.wsgi_app = TinymonWSGI(app.wsgi_app)
+
+The middleware captures with per-event request context (method + URL from
+environ) and RE-RAISES — your framework's normal error handling still fires.
+"""
+from __future__ import annotations
+
+from typing import Any, Callable, Iterable
+
+import tinymonpy as _tm
+
+
+def _url_from_environ(environ: dict) -> str:
+    scheme = environ.get("wsgi.url_scheme", "http")
+    host = environ.get("HTTP_HOST") or environ.get("SERVER_NAME", "")
+    path = environ.get("RAW_URI") or (
+        environ.get("SCRIPT_NAME", "") + environ.get("PATH_INFO", "")
+    )
+    qs = environ.get("QUERY_STRING")
+    if qs:
+        path = f"{path}?{qs}"
+    return f"{scheme}://{host}{path}" if host else path
+
+
+class TinymonWSGI:
+    """Wrap a WSGI callable; capture exceptions, then re-raise."""
+
+    def __init__(self, app: Callable[..., Iterable[bytes]]) -> None:
+        self.app = app
+
+    def __call__(self, environ: dict, start_response: Callable[..., Any]):
+        try:
+            return self.app(environ, start_response)
+        except BaseException as exc:
+            client = _tm._client  # type: ignore[attr-defined]
+            if client is not None:
+                try:
+                    client.capture_exception_with_context(
+                        exc,
+                        request={
+                            "method": environ.get("REQUEST_METHOD"),
+                            "url": _url_from_environ(environ),
+                        },
+                    )
+                except Exception:
+                    pass
+            raise

{tinymonpy-0.2.0 → tinymonpy-0.3.0}/tinymonpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinymonpy
-Version: 0.2.0
+Version: 0.3.0
 Summary: Tiny error monitoring SDK for Python.
 Author: tinymon
 License: MIT

{tinymonpy-0.2.0 → tinymonpy-0.3.0}/tinymonpy.egg-info/SOURCES.txt

@@ -12,4 +12,7 @@ tinymonpy.egg-info/PKG-INFO
 tinymonpy.egg-info/SOURCES.txt
 tinymonpy.egg-info/dependency_links.txt
 tinymonpy.egg-info/requires.txt
-tinymonpy.egg-info/top_level.txt
+tinymonpy.egg-info/top_level.txt
+tinymonpy/frameworks/__init__.py
+tinymonpy/frameworks/asgi.py
+tinymonpy/frameworks/wsgi.py