tinymonpy 0.1.0__tar.gz → 0.3.0__tar.gz

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

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

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

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

{tinymonpy-0.1.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.1.0"
+__version__ = "0.3.0"
 
 _client: Optional[Client] = None
 
@@ -47,6 +48,10 @@ def init(
     release: Optional[str] = None,
     sample_rate: float = 1.0,
     before_send: Optional[Callable[[Dict[str, Any]], Optional[Dict[str, Any]]]] = None,
+    # Privacy controls. See https://tinymon.dev/docs/privacy.html
+    scrub_url_query: bool = True,
+    scrub_patterns: Optional[list] = None,
+    send_default_pii: bool = False,
 ) -> None:
     global _client
     _client = Client(
@@ -56,6 +61,9 @@ def init(
         release=release,
         sample_rate=sample_rate,
         before_send=before_send,
+        scrub_url_query=scrub_url_query,
+        scrub_patterns=scrub_patterns,
+        send_default_pii=send_default_pii,
     )
     install_global_handlers(_client)
 
@@ -65,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.3.0/tinymonpy/client.py

@@ -0,0 +1,118 @@
+"""The Client orchestrates capture: build event, scrub, run before_send, enqueue."""
+from __future__ import annotations
+
+import random
+from typing import Any, Callable, Dict, List, Optional, Pattern
+
+from .event_builder import build_event
+from .scope import scope
+from .scrub import scrub_event
+from .transport import Transport
+
+_DEFAULT_ENDPOINT = "https://console.tinymon.dev/api/ingest"
+
+BeforeSend = Callable[[Dict[str, Any]], Optional[Dict[str, Any]]]
+
+
+class Client:
+    def __init__(
+        self,
+        dsn: str,
+        *,
+        endpoint: Optional[str] = None,
+        environment: Optional[str] = None,
+        release: Optional[str] = None,
+        sample_rate: float = 1.0,
+        before_send: Optional[BeforeSend] = None,
+        # Privacy controls — defaults are privacy-preserving.
+        scrub_url_query: bool = True,
+        scrub_patterns: Optional[List[Pattern[str]]] = None,
+        send_default_pii: bool = False,
+    ) -> None:
+        self.dsn = dsn
+        self.endpoint = endpoint or _DEFAULT_ENDPOINT
+        self.environment = environment
+        self.release = release
+        self.sample_rate = sample_rate
+        self.before_send = before_send
+        self.scrub_url_query = scrub_url_query
+        self.scrub_patterns = scrub_patterns
+        self.send_default_pii = send_default_pii
+        self.transport = Transport(self.endpoint, dsn)
+
+    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=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(
+            event,
+            scrub_url_query=self.scrub_url_query,
+            scrub_patterns=self.scrub_patterns,
+        )
+        # PII gate on the wire — server only attaches IP if true.
+        event["send_default_pii"] = bool(self.send_default_pii)
+        if self.before_send is not None:
+            result = self.before_send(event)
+            if result is None:
+                return None
+            event = result
+        return event
+
+    def capture_exception(self, exc: BaseException) -> None:
+        try:
+            if random.random() > self.sample_rate:
+                return
+            event = self._prepare(exc)
+            if event is None:
+                return
+            self.transport.enqueue(event)
+        except Exception:
+            # 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))
+            if event is None:
+                return
+            event["level"] = level
+            event["exception"]["type"] = "Message"
+            self.transport.enqueue(event)
+        except Exception:
+            pass

{tinymonpy-0.1.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.3.0/tinymonpy/scrub.py

@@ -0,0 +1,67 @@
+"""Default PII scrub. Identical semantics to the JS SDK and the server.
+
+Runs BEFORE before_send so user hooks can both relax and tighten the defaults.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional, Pattern
+
+SENSITIVE_TAG_KEY: Pattern[str] = re.compile(
+    r"password|token|secret|auth|card|cvv|ssn", re.IGNORECASE
+)
+
+_EMAIL = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")
+_CARD = re.compile(r"\b(?:\d[ -]?){12,15}\d\b")
+_BEARER = re.compile(r"\b[Bb]earer\s+[A-Za-z0-9._\-]+")
+_AUTH_HDR = re.compile(r"\bAuthorization\s*:\s*\S+")
+
+DEFAULT_PATTERNS: List[Pattern[str]] = [_EMAIL, _CARD, _BEARER, _AUTH_HDR]
+
+
+def _scrub_string(s: str, patterns: List[Pattern[str]]) -> str:
+    out = s
+    for re_ in patterns:
+        out = re_.sub("[redacted]", out)
+    return out
+
+
+def _strip_url_query(url: Optional[str]) -> Optional[str]:
+    if not url:
+        return url
+    for i, ch in enumerate(url):
+        if ch in "?#":
+            return url[:i]
+    return url
+
+
+def scrub_event(
+    event: Dict[str, Any],
+    *,
+    scrub_url_query: bool = True,
+    scrub_patterns: Optional[List[Pattern[str]]] = None,
+) -> Dict[str, Any]:
+    """Mutate the event dict in place. Returns it for chaining."""
+    patterns = list(DEFAULT_PATTERNS) + list(scrub_patterns or [])
+
+    req = event.get("request") or {}
+    if scrub_url_query and req.get("url"):
+        req["url"] = _strip_url_query(req.get("url"))
+        event["request"] = req
+
+    exc = event.get("exception") or {}
+    if exc.get("value"):
+        exc["value"] = _scrub_string(exc["value"], patterns)
+
+    for b in event.get("breadcrumbs") or []:
+        if b.get("message"):
+            b["message"] = _scrub_string(b["message"], patterns)
+
+    tags = event.get("tags")
+    if tags:
+        cleaned: Dict[str, str] = {}
+        for k, v in tags.items():
+            cleaned[k] = "[redacted]" if SENSITIVE_TAG_KEY.search(k) else v
+        event["tags"] = cleaned
+
+    return event

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

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

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

@@ -5,10 +5,14 @@ tinymonpy/client.py
 tinymonpy/event_builder.py
 tinymonpy/integrations.py
 tinymonpy/scope.py
+tinymonpy/scrub.py
 tinymonpy/stacktrace.py
 tinymonpy/transport.py
 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

tinymonpy-0.1.0/tinymonpy/client.py

@@ -1,75 +0,0 @@
-"""The Client orchestrates capture: build event, run beforeSend, enqueue."""
-from __future__ import annotations
-
-import random
-from typing import Any, Callable, Dict, Optional
-
-from .event_builder import build_event
-from .scope import scope
-from .transport import Transport
-
-_DEFAULT_ENDPOINT = "https://console.tinymon.dev/api/ingest"
-
-BeforeSend = Callable[[Dict[str, Any]], Optional[Dict[str, Any]]]
-
-
-class Client:
-    def __init__(
-        self,
-        dsn: str,
-        *,
-        endpoint: Optional[str] = None,
-        environment: Optional[str] = None,
-        release: Optional[str] = None,
-        sample_rate: float = 1.0,
-        before_send: Optional[BeforeSend] = None,
-    ) -> None:
-        self.dsn = dsn
-        self.endpoint = endpoint or _DEFAULT_ENDPOINT
-        self.environment = environment
-        self.release = release
-        self.sample_rate = sample_rate
-        self.before_send = before_send
-        self.transport = Transport(self.endpoint, dsn)
-
-    def capture_exception(self, exc: BaseException) -> None:
-        try:
-            if random.random() > self.sample_rate:
-                return
-            snap = scope.snapshot()
-            event = build_event(
-                exc,
-                release=self.release,
-                environment=self.environment,
-                user=snap["user"],
-                tags=snap["tags"],
-                breadcrumbs=snap["breadcrumbs"],
-            )
-            if self.before_send is not None:
-                result = self.before_send(event)
-                if result is None:
-                    return
-                event = result
-            self.transport.enqueue(event)
-        except Exception:
-            # SWALLOW. The SDK must never throw into the host app.
-            pass
-
-    def capture_message(self, message: str, level: str = "info") -> None:
-        try:
-            # Synthesize an exception without a stack — value carries the message.
-            synthetic = Exception(message)
-            snap = scope.snapshot()
-            event = build_event(
-                synthetic,
-                release=self.release,
-                environment=self.environment,
-                user=snap["user"],
-                tags=snap["tags"],
-                breadcrumbs=snap["breadcrumbs"],
-            )
-            event["level"] = level
-            event["exception"]["type"] = "Message"
-            self.transport.enqueue(event)
-        except Exception:
-            pass