insider-python 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

insider/_version.py

@@ -5,4 +5,4 @@ lookup on every beacon. Bump this and `[project].version` together when
 cutting a release.
 """
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"

insider/client.py

@@ -18,7 +18,7 @@ import atexit
 import os
 import subprocess
 import threading
-from typing import Any, Callable, Dict, Iterable, List, Optional
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Union
 
 from ._envelope import build_envelope, enforce_size_budget
 from ._version import __version__
@@ -33,6 +33,16 @@ from .transport import BackgroundTransport
 VALID_KINDS = {"error", "perf", "log", "custom"}
 VALID_LEVELS = {"debug", "info", "warning", "error", "fatal"}
 
+IntegrationLike = Union[Any, type]
+
+
+def _setup_integrations(integrations: Sequence[IntegrationLike]) -> None:
+    for integration in integrations:
+        instance = integration() if isinstance(integration, type) else integration
+        setup_once = getattr(instance, "setup_once", None)
+        if callable(setup_once):
+            setup_once()
+
 
 # ---------------------------------------------------------------------------
 # DSN resolution
@@ -259,6 +269,8 @@ def _set_active(client: Optional[Client]) -> None:
 @safe
 def init(
     dsn: Optional[str] = None,
+    *,
+    integrations: Optional[Sequence[IntegrationLike]] = None,
     **kwargs: Any,
 ) -> Optional[Client]:
     """
@@ -268,6 +280,9 @@ def init(
     Calling `init` a second time is allowed but logs a warning and
     closes the previous client first. The new client becomes the
     process-global one.
+
+    Pass framework integrations via `integrations=[...]`. Each integration's
+    `setup_once()` runs after the client is active.
     """
     global _active_client
     raw = _resolve_dsn_string(dsn)
@@ -280,6 +295,8 @@ def init(
         debug(f"invalid DSN: {exc}; entering disabled mode")
         return None
 
+    integration_list = list(integrations or [])
+
     with _init_lock:
         if _active_client is not None:
             debug("re-initializing; closing previous client")
@@ -290,6 +307,7 @@ def init(
         client = Client(parsed, **kwargs)
         _set_active(client)
 
+    _setup_integrations(integration_list)
     atexit.register(_atexit_close)
     return client
 

insider/contrib/django/apps.py

@@ -13,6 +13,7 @@ from typing import Any, Dict
 from django.apps import AppConfig
 
 from ... import init
+from ...integrations.django import DjangoIntegration
 from ...safety import debug
 
 
@@ -57,4 +58,4 @@ class InsiderConfig(AppConfig):
         # env-var fallback in `init` still applies if Django's settings
         # didn't define it.
         dsn = kwargs.pop("dsn", None)
-        init(dsn, **kwargs)
+        init(dsn, integrations=[DjangoIntegration()], **kwargs)

insider/contrib/django/middleware.py

@@ -4,6 +4,10 @@ auto-capture any unhandled exception that escapes a view.
 
 The middleware is a no-op when the SDK is in disabled mode.
 
+Prefer the Sentry-style integration instead — see
+`insider.integrations.django.DjangoIntegration` and `wsgi.py` init.
+This middleware remains for backward compatibility.
+
 What we attach to the scope:
 
   - method, path, route (URL name if available), query_string
@@ -25,31 +29,12 @@ None so Django continues its normal 500 handling.
 
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable
 
-from ... import capture_exception
 from ...client import _client
-from ...safety import debug, safe
-
-
-# Request headers that are safe to forward to the dashboard. We keep an
-# allow-list rather than a deny-list because there are too many possible
-# custom headers to enumerate scary ones. Scrubbing further masks names
-# matching the default deny-list (Authorization, Cookie, etc.) at envelope
-# build time.
-_SAFE_HEADERS = {
-    "accept",
-    "accept-encoding",
-    "accept-language",
-    "content-type",
-    "content-length",
-    "host",
-    "referer",
-    "user-agent",
-    "x-forwarded-for",
-    "x-real-ip",
-    "x-request-id",
-}
+from ...integrations.django.capture import capture_request_exception
+from ...integrations.django.request import build_request_ctx
+from ...safety import safe
 
 
 class InsiderMiddleware:
@@ -67,7 +52,7 @@ class InsiderMiddleware:
         if client is None:
             return self.get_response(request)
 
-        ctx = self._build_request_ctx(request, client.send_default_pii)
+        ctx = build_request_ctx(request, client.send_default_pii)
         client.scope.set_request(ctx)
         try:
             return self.get_response(request)
@@ -76,89 +61,5 @@ class InsiderMiddleware:
 
     @safe
     def process_exception(self, request: Any, exception: BaseException) -> None:
-        # Scope's already set in __call__; capture inherits the request ctx.
-        capture_exception(exception)
-        return None  # let Django render the 500
-
-    # ------------------------------------------------------------------
-
-    @staticmethod
-    def _build_request_ctx(request: Any, send_default_pii: bool) -> Dict[str, Any]:
-        try:
-            method = getattr(request, "method", None)
-            path = getattr(request, "path", None)
-            query = getattr(request, "META", {}).get("QUERY_STRING") or None
-            route = None
-            try:
-                # ResolverMatch is set after urls resolve; in middleware
-                # __call__ before view, it's usually None. We still try.
-                match = getattr(request, "resolver_match", None)
-                if match is not None:
-                    route = match.view_name
-            except Exception:
-                pass
-
-            headers = _extract_headers(getattr(request, "META", {}))
-
-            ctx: Dict[str, Any] = {
-                "method": method,
-                "path": path,
-                "query_string": query,
-                "route": route,
-                "headers": headers,
-            }
-
-            if send_default_pii:
-                ctx["body"] = _read_body(request)
-                user = getattr(request, "user", None)
-                user_id = getattr(user, "id", None) if user is not None else None
-                if user_id is not None:
-                    ctx["user"] = {"id": user_id}
-
-            return ctx
-        except Exception as exc:
-            debug(f"request ctx build failed: {exc}")
-            return {}
-
-
-def _extract_headers(meta: Dict[str, Any]) -> Dict[str, str]:
-    """Convert Django's META dict into a real headers dict, allow-listed."""
-    headers: Dict[str, str] = {}
-    for key, value in meta.items():
-        if not key.startswith("HTTP_") and key not in (
-            "CONTENT_TYPE",
-            "CONTENT_LENGTH",
-        ):
-            continue
-        name = key
-        if key.startswith("HTTP_"):
-            name = key[len("HTTP_") :]
-        name = name.replace("_", "-").lower()
-        if name not in _SAFE_HEADERS:
-            # We still include unknown headers; the scrubber will mask any
-            # whose name is in the deny-list. But we cap obviously huge or
-            # weird ones here.
-            if len(str(value)) > 4096:
-                continue
-        try:
-            headers[name] = str(value)
-        except Exception:
-            pass
-    return headers
-
-
-def _read_body(request: Any) -> Optional[str]:
-    """
-    Return a string version of the request body, or None.
-    We don't consume `request.body` if it hasn't been read yet, to avoid
-    breaking downstream views; if it's accessible, we take it.
-    """
-    try:
-        raw = getattr(request, "body", None)
-        if raw is None:
-            return None
-        if isinstance(raw, bytes):
-            return raw.decode("utf-8", errors="replace")
-        return str(raw)
-    except Exception:
+        capture_request_exception(request, exception)
         return None

insider/integrations/__init__.py

@@ -0,0 +1,20 @@
+"""
+Framework integrations for Insider.
+
+Each integration exposes a `setup_once()` hook that patches into the host
+framework exactly once per process. Pass instances to `insider.init`:
+
+    insider.init(dsn=..., integrations=[DjangoIntegration()])
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class Integration(Protocol):
+    """Minimal integration contract."""
+
+    def setup_once(self) -> None:
+        """Install hooks into the host framework. Idempotent."""

insider/integrations/django/__init__.py

@@ -0,0 +1,50 @@
+"""
+Sentry-style Django integration.
+
+Install with `insider.init(..., integrations=[DjangoIntegration()])` in
+`wsgi.py` / `asgi.py` before `get_wsgi_application()`. No middleware or
+`INSTALLED_APPS` wiring required.
+
+Hooks installed (each once per process):
+
+  - `got_request_exception` → auto-capture unhandled view errors
+  - `BaseHandler.get_response` → request context on the SDK scope
+  - `WSGIHandler.__call__` → capture catastrophic escapes
+  - `APIView.initial` (when DRF is present) → DRF request body access
+"""
+
+from __future__ import annotations
+
+import threading
+
+from ...safety import debug, safe
+from . import drf, handler, signals, wsgi
+
+
+class DjangoIntegration:
+    """Patch Django's request/exception path for automatic error capture."""
+
+    identifier = "django"
+
+    _lock = threading.Lock()
+    _installed = False
+
+    @safe
+    def setup_once(self) -> None:
+        cls = type(self)
+        with cls._lock:
+            if cls._installed:
+                return
+            cls._installed = True
+
+        try:
+            import django  # noqa: F401
+        except ImportError:
+            debug("DjangoIntegration: django is not installed")
+            cls._installed = False
+            return
+
+        signals.install()
+        handler.install()
+        wsgi.install()
+        drf.install()

insider/integrations/django/capture.py

@@ -0,0 +1,43 @@
+"""
+Shared request-exception capture with de-duplication.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ... import capture_exception
+from ...client import _client
+from ...safety import safe
+from .request import build_request_ctx
+
+_CAPTURED_ATTR = "_insider_exception_captured"
+
+
+@safe
+def capture_request_exception(request: Any, exception: BaseException) -> None:
+    """
+    Capture an unhandled request exception once per request.
+
+    Middleware `process_exception` and Django's `got_request_exception`
+    signal can both fire for the same failure; the request flag prevents
+    double-beaming.
+    """
+    if getattr(request, _CAPTURED_ATTR, False):
+        return
+    setattr(request, _CAPTURED_ATTR, True)
+
+    client = _client()
+    if client is None:
+        return
+
+    # Scope may already be set by middleware or the get_response patch.
+    if client.scope.current_request() is None:
+        ctx = build_request_ctx(request, client.send_default_pii)
+        client.scope.set_request(ctx)
+        try:
+            capture_exception(exception)
+        finally:
+            client.scope.clear_request()
+    else:
+        capture_exception(exception)

insider/integrations/django/drf.py

@@ -0,0 +1,40 @@
+"""
+Optional DRF patch: link DRF Request objects for accurate body reads.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ...safety import debug, safe
+from .request import attach_drf_request_backref
+
+_patched = False
+
+
+def install() -> None:
+    global _patched
+    if _patched:
+        return
+    try:
+        from rest_framework.views import APIView
+    except ImportError:
+        return
+
+    old_initial = APIView.initial
+
+    @safe
+    def patched_initial(
+        self: Any,
+        request: Any,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        try:
+            attach_drf_request_backref(request._request, request)
+        except Exception as exc:
+            debug(f"drf initial backref failed: {exc}")
+        return old_initial(self, request, *args, **kwargs)
+
+    APIView.initial = patched_initial  # type: ignore[method-assign]
+    _patched = True

insider/integrations/django/handler.py

@@ -0,0 +1,42 @@
+"""
+Patch `BaseHandler.get_response` to attach request context for the request lifetime.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from ...client import _client
+from ...safety import debug, safe
+from .request import build_request_ctx
+
+_patched = False
+
+
+def install() -> None:
+    global _patched
+    if _patched:
+        return
+    try:
+        from django.core.handlers.base import BaseHandler
+    except ImportError:
+        debug("django BaseHandler unavailable; skipping get_response patch")
+        return
+
+    old_get_response = BaseHandler.get_response
+
+    @safe
+    def patched_get_response(self: Any, request: Any) -> Any:
+        client = _client()
+        if client is None:
+            return old_get_response(self, request)
+
+        ctx = build_request_ctx(request, client.send_default_pii)
+        client.scope.set_request(ctx)
+        try:
+            return old_get_response(self, request)
+        finally:
+            client.scope.clear_request()
+
+    BaseHandler.get_response = patched_get_response  # type: ignore[method-assign]
+    _patched = True

insider/integrations/django/request.py

@@ -0,0 +1,140 @@
+"""
+Build Insider request-context dicts from Django (and DRF) request objects.
+"""
+
+from __future__ import annotations
+
+import weakref
+from typing import Any, Dict, Optional
+
+from ...safety import debug
+
+# Request headers that are safe to forward to the dashboard. We keep an
+# allow-list rather than a deny-list because there are too many possible
+# custom headers to enumerate scary ones. Scrubbing further masks names
+# matching the default deny-list (Authorization, Cookie, etc.) at envelope
+# build time.
+_SAFE_HEADERS = {
+    "accept",
+    "accept-encoding",
+    "accept-language",
+    "content-type",
+    "content-length",
+    "host",
+    "referer",
+    "user-agent",
+    "x-forwarded-for",
+    "x-real-ip",
+    "x-request-id",
+}
+
+_DRF_BACKREF_ATTR = "_insider_drf_request_backref"
+
+
+def attach_drf_request_backref(django_request: Any, drf_request: Any) -> None:
+    """Link a DRF Request to its wrapped Django request for body reads."""
+    try:
+        setattr(django_request, _DRF_BACKREF_ATTR, weakref.ref(drf_request))
+    except Exception as exc:
+        debug(f"drf request backref failed: {exc}")
+
+
+def build_request_ctx(request: Any, send_default_pii: bool) -> Dict[str, Any]:
+    try:
+        request = _resolve_drf_request(request)
+
+        method = getattr(request, "method", None)
+        path = getattr(request, "path", None)
+        meta = getattr(request, "META", {})
+        query = meta.get("QUERY_STRING") or None
+        route = None
+        try:
+            match = getattr(request, "resolver_match", None)
+            if match is not None:
+                route = match.view_name
+        except Exception:
+            pass
+
+        headers = _extract_headers(meta)
+
+        ctx: Dict[str, Any] = {
+            "method": method,
+            "path": path,
+            "query_string": query,
+            "route": route,
+            "headers": headers,
+        }
+
+        if send_default_pii:
+            ctx["body"] = _read_body(request)
+            user = getattr(request, "user", None)
+            user_id = getattr(user, "id", None) if user is not None else None
+            if user_id is not None:
+                ctx["user"] = {"id": user_id}
+
+        return ctx
+    except Exception as exc:
+        debug(f"request ctx build failed: {exc}")
+        return {}
+
+
+def _resolve_drf_request(request: Any) -> Any:
+    """Prefer the DRF Request when a weak backref was attached in `initial`."""
+    try:
+        backref = getattr(request, _DRF_BACKREF_ATTR, None)
+        if backref is not None:
+            drf_request = backref()
+            if drf_request is not None:
+                return drf_request
+    except Exception:
+        pass
+    return request
+
+
+def _extract_headers(meta: Dict[str, Any]) -> Dict[str, str]:
+    """Convert Django's META dict into a real headers dict, allow-listed."""
+    headers: Dict[str, str] = {}
+    for key, value in meta.items():
+        if not key.startswith("HTTP_") and key not in (
+            "CONTENT_TYPE",
+            "CONTENT_LENGTH",
+        ):
+            continue
+        name = key
+        if key.startswith("HTTP_"):
+            name = key[len("HTTP_") :]
+        name = name.replace("_", "-").lower()
+        if name not in _SAFE_HEADERS:
+            if len(str(value)) > 4096:
+                continue
+        try:
+            headers[name] = str(value)
+        except Exception:
+            pass
+    return headers
+
+
+def _read_body(request: Any) -> Optional[str]:
+    """
+    Return a string version of the request body, or None.
+    We don't consume `request.body` if it hasn't been read yet, to avoid
+    breaking downstream views; if it's accessible, we take it.
+    """
+    try:
+        data = getattr(request, "data", None)
+        if data is not None and not isinstance(data, (str, bytes)):
+            try:
+                import json
+
+                return json.dumps(data)
+            except Exception:
+                return str(data)
+
+        raw = getattr(request, "body", None)
+        if raw is None:
+            return None
+        if isinstance(raw, bytes):
+            return raw.decode("utf-8", errors="replace")
+        return str(raw)
+    except Exception:
+        return None

insider/integrations/django/signals.py

@@ -0,0 +1,39 @@
+"""
+Connect Django's `got_request_exception` signal to Insider capture.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from ...safety import debug, safe
+from .capture import capture_request_exception
+
+_connected = False
+
+
+def install() -> None:
+    global _connected
+    if _connected:
+        return
+    try:
+        from django.core import signals
+    except ImportError:
+        debug("django signals unavailable; skipping got_request_exception hook")
+        return
+
+    signals.got_request_exception.connect(_on_got_request_exception)
+    _connected = True
+
+
+@safe
+def _on_got_request_exception(
+    sender: Any,
+    request: Any,
+    **kwargs: Any,
+) -> None:
+    exc = sys.exc_info()[1]
+    if exc is None:
+        return
+    capture_request_exception(request, exc)

insider/integrations/django/wsgi.py

@@ -0,0 +1,43 @@
+"""
+Patch `WSGIHandler.__call__` to capture exceptions that escape Django entirely.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from ... import capture_exception
+from ...client import _client
+from ...safety import debug, safe
+
+_patched = False
+
+
+def install() -> None:
+    global _patched
+    if _patched:
+        return
+    try:
+        from django.core.handlers.wsgi import WSGIHandler
+    except ImportError:
+        debug("django WSGIHandler unavailable; skipping WSGI patch")
+        return
+
+    old_call: Callable[..., Any] = WSGIHandler.__call__
+
+    @safe
+    def patched_call(
+        self: Any,
+        environ: Any,
+        start_response: Any,
+    ) -> Any:
+        if _client() is None:
+            return old_call(self, environ, start_response)
+        try:
+            return old_call(self, environ, start_response)
+        except BaseException as exc:
+            capture_exception(exc)
+            raise
+
+    WSGIHandler.__call__ = patched_call  # type: ignore[method-assign]
+    _patched = True

{insider_python-0.1.2.dist-info → insider_python-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: insider-python
-Version: 0.1.2
+Version: 0.1.3
 Summary: Python SDK for Insider — ship Beacons to your Insider server.
 Author: Insider
 License-Expression: MIT
@@ -24,6 +24,7 @@ Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: pytest-django>=4.8; extra == "dev"
 Requires-Dist: django>=4.2; extra == "dev"
+Requires-Dist: djangorestframework>=3.14; extra == "dev"
 
 # insider-python
 
@@ -68,26 +69,31 @@ insider.capture_message("cache miss spiked", level="warning")
 
 ### Django
 
-Add the integration to `INSTALLED_APPS` and configure via settings:
+Initialize in `wsgi.py` (or `asgi.py`) before `get_wsgi_application()`:
 
 ```python
-INSTALLED_APPS = [
-    # ...
-    "insider.contrib.django",
-]
-
-MIDDLEWARE = [
-    # ...
-    "insider.contrib.django.middleware.InsiderMiddleware",
-]
-
-INSIDER_DSN = "https://<beacon_token>@insider.example.com/<project_uuid>"
-INSIDER_ENVIRONMENT = "production"
-INSIDER_RELEASE = "1.2.3"
+import os
+import insider
+from insider.integrations.django import DjangoIntegration
+
+insider.init(
+    dsn=os.environ.get("INSIDER_DSN"),
+    environment="production",
+    release="1.2.3",
+    integrations=[DjangoIntegration()],
+)
+
+from django.core.wsgi import get_wsgi_application
+application = get_wsgi_application()
 ```
 
-That's the whole setup. Every unhandled exception in a view is now a
-Beacon in your dashboard.
+That's the whole setup. Every unhandled exception in a view — including
+Django REST Framework API views — is now a Beacon in your dashboard.
+No middleware, no `INSTALLED_APPS`, and no `EXCEPTION_HANDLER` wiring.
+
+**Legacy setup** (still supported): add `insider.contrib.django` to
+`INSTALLED_APPS` and `InsiderMiddleware` to `MIDDLEWARE`. Prefer the
+`wsgi.py` pattern for new projects.
 
 ## Configuration
 

insider_python-0.1.3.dist-info/RECORD

@@ -0,0 +1,27 @@
+insider/__init__.py,sha256=DgDevX2wcy9lonZiHaq5dJLieD3_fp3p6l3lotuTpGE,781
+insider/_envelope.py,sha256=mZiNl-Cha4piAhbIgFuU_KOZnaK4GMrYquFJxLn0D5Q,6684
+insider/_version.py,sha256=tSvSo1IuInvJvdgaCfYY3AwA4nRKslqnuXXy0IEtaZE,246
+insider/client.py,sha256=MkwlGp6iIMNsoHtg9pDWX1OqxetC27rmODh5y5qQtyI,12196
+insider/dsn.py,sha256=S8BbRhmKKKU1N6W8cpMSQoyDO_EuUJ1PkcjhGrrf5hw,3009
+insider/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+insider/safety.py,sha256=mtzzWLujuvmd24W2VtVcMGO_81GPBbB2tYuVqU2KsuI,1910
+insider/scope.py,sha256=F1eMWt6uu14uBdncc5DC6Lh735EPcUv1yF4prBi--pc,1708
+insider/scrubbing.py,sha256=U8N3MS5VtDUNpIWN4PZ8bvrPqmjRRXq5hWGXxzoF5Gw,2853
+insider/stacktrace.py,sha256=tgdS9dQ-bVyz59_874BstuCYaP6rGn2k6HMo9sW8Ks8,5310
+insider/transport.py,sha256=8ncFb3C0LgF2hMRoj_fhxj49NIUD6hsVAHfPZKtNcn4,7292
+insider/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+insider/contrib/django/__init__.py,sha256=UMGrJgVO-FqszZo9Cviw7oWS8PLdXVHt3hwXZ_YMj8A,680
+insider/contrib/django/apps.py,sha256=Ct584Pa-S9I82omP3t_Xsn4NrdlqfoNf0eUN9xFa7Hs,2036
+insider/contrib/django/middleware.py,sha256=lX5sGDZw4rJ6gsNEcOpqHspkvzqilxTlUxOszQxwzpI,2077
+insider/integrations/__init__.py,sha256=MrpszNOGT5-2b2310wS3GDjIQWQ7R_-S-OYIMZ5iu1E,526
+insider/integrations/django/__init__.py,sha256=EIUHPMhBSw4pXWaXiteYh5lzThYEzE9gAZBfDypnu4M,1325
+insider/integrations/django/capture.py,sha256=UQfOdHvbD2mhHaTntQq-mXMDpho199V7j6BR6k6ppWY,1182
+insider/integrations/django/drf.py,sha256=MXY4erP9gPBiEvf8Hi0CLrUBczXY1o7Y5wVCjSsQeCY,899
+insider/integrations/django/handler.py,sha256=V2lUvkqWBtechnd2Kj6wToxmWZqpbG7E8BKOxYap-fc,1103
+insider/integrations/django/request.py,sha256=pOuQxnFWeA3KPAc0eVaRtkxGRyr2PetGKEg7OlTnqF4,4181
+insider/integrations/django/signals.py,sha256=kwH7npDG3AC9MILB9f4YUYofy5iwOosapGkBm_3dZY4,802
+insider/integrations/django/wsgi.py,sha256=kJ5qo5LUdRYJtp4NkiD38DZzbb__idJU6FAltYhgtus,1044
+insider_python-0.1.3.dist-info/METADATA,sha256=TL3DKG0aJQXFcKFZJi1Ri6F3BrDaTATEDECgWCtt0t8,3971
+insider_python-0.1.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+insider_python-0.1.3.dist-info/top_level.txt,sha256=g_YKp2jCaaefmasZ2nOa9capm0X8q2sAWI_eEClKIos,8
+insider_python-0.1.3.dist-info/RECORD,,

insider_python-0.1.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-insider/__init__.py,sha256=DgDevX2wcy9lonZiHaq5dJLieD3_fp3p6l3lotuTpGE,781
-insider/_envelope.py,sha256=mZiNl-Cha4piAhbIgFuU_KOZnaK4GMrYquFJxLn0D5Q,6684
-insider/_version.py,sha256=lxOKSZJbU9hAXhlPRaq8AWb80mXq8wTnJsQhaOYn7ao,246
-insider/client.py,sha256=qLl7iQQ1N4zygXisGxOOyXNkq16UuWozhEHPGK_24Xs,11540
-insider/dsn.py,sha256=S8BbRhmKKKU1N6W8cpMSQoyDO_EuUJ1PkcjhGrrf5hw,3009
-insider/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-insider/safety.py,sha256=mtzzWLujuvmd24W2VtVcMGO_81GPBbB2tYuVqU2KsuI,1910
-insider/scope.py,sha256=F1eMWt6uu14uBdncc5DC6Lh735EPcUv1yF4prBi--pc,1708
-insider/scrubbing.py,sha256=U8N3MS5VtDUNpIWN4PZ8bvrPqmjRRXq5hWGXxzoF5Gw,2853
-insider/stacktrace.py,sha256=tgdS9dQ-bVyz59_874BstuCYaP6rGn2k6HMo9sW8Ks8,5310
-insider/transport.py,sha256=8ncFb3C0LgF2hMRoj_fhxj49NIUD6hsVAHfPZKtNcn4,7292
-insider/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-insider/contrib/django/__init__.py,sha256=UMGrJgVO-FqszZo9Cviw7oWS8PLdXVHt3hwXZ_YMj8A,680
-insider/contrib/django/apps.py,sha256=WOKn-fNp_SSPNyt8xXz_fXYVhkyepafAi1uxpWC9_Bo,1947
-insider/contrib/django/middleware.py,sha256=JWnP_p4JBGyKQMswevjWxoUBSE5o4xgLKYOm1Zrb30g,5365
-insider_python-0.1.2.dist-info/METADATA,sha256=ag7XgxFizqFCl4TuPkSlcid8kCp3qvdj6dzyj5Kr0bM,3581
-insider_python-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-insider_python-0.1.2.dist-info/top_level.txt,sha256=g_YKp2jCaaefmasZ2nOa9capm0X8q2sAWI_eEClKIos,8
-insider_python-0.1.2.dist-info/RECORD,,