insider-python 0.1.4__py3-none-any.whl → 0.3.0__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.4"
+__version__ = "0.3.0"

insider/integrations/django/__init__.py

@@ -2,24 +2,29 @@
 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.
+`wsgi.py` / `asgi.py` before `get_wsgi_application()` or
+`get_asgi_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
+  - `BaseHandler.get_response` → request context on the SDK scope (WSGI + ASGI HTTP)
+  - `WSGIHandler.__call__` → capture catastrophic WSGI escapes
+  - `ASGIHandler.__call__` → capture catastrophic ASGI escapes
   - `APIView.initial` (when DRF is present) → DRF request body access
   - Auto `kind=request` beacon per HTTP request (optional, default on)
+
+Channels / `ProtocolTypeRouter`: use `wrap_asgi_application()` on the HTTP
+branch with `DjangoIntegration(auto_perf=False)` — see `asgi.py`.
 """
 
 from __future__ import annotations
 
 import threading
+from typing import Any, Dict
 
-from ...safety import debug, safe
-from . import drf, handler, signals, wsgi
+from ...safety import debug
+from . import asgi, drf, handler, signals, wsgi
 
 
 class DjangoIntegration:
@@ -34,27 +39,83 @@ class DjangoIntegration:
         """
         Args:
             auto_perf: When True (default), emit one `kind=request` beacon
-                after every HTTP request. Disable for high-traffic apps until
-                server-side sampling lands.
+                after every HTTP request via the `get_response` patch.
+                Set False when using `wrap_asgi_application()` on the HTTP
+                branch of a Channels router (avoids double capture).
         """
         self.auto_perf = auto_perf
 
-    @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()
+        # Patch get_response first. Optional hooks below must not block this.
         handler.install(auto_perf=self.auto_perf)
-        wsgi.install()
-        drf.install()
+        if not handler._patched:
+            debug(
+                "DjangoIntegration: get_response patch failed — "
+                "call insider.init() before get_wsgi_application() / "
+                "get_asgi_application()"
+            )
+            return
+
+        with cls._lock:
+            cls._installed = True
+
+        for label, install in (
+            ("signals", signals.install),
+            ("wsgi", wsgi.install),
+            ("asgi", asgi.install),
+            ("drf", drf.install),
+        ):
+            try:
+                install()
+            except Exception as exc:
+                debug(f"DjangoIntegration: {label} hook failed: {exc}")
+
+        _log_integration_status()
+
+    @classmethod
+    def reset_for_tests(cls) -> None:
+        """Test helper — allow `setup_once()` to run again in the same process."""
+        with cls._lock:
+            cls._installed = False
+
+
+def get_integration_status() -> Dict[str, Any]:
+    """Return which Django hooks are active in this process (tests + debug)."""
+    return {
+        "handler": handler._patched,
+        "handler_auto_perf": handler._auto_perf,
+        "wsgi": wsgi._patched,
+        "asgi_handler": asgi._handler_patched,
+        "signals": signals._connected,
+        "response_for_exception": signals._rfe_patched,
+        "drf": drf._patched,
+    }
+
+
+def _log_integration_status() -> None:
+    status = get_integration_status()
+    debug(
+        "DjangoIntegration: "
+        + ", ".join(f"{key}={value}" for key, value in status.items())
+    )
+
+
+__all__ = [
+    "DjangoIntegration",
+    "get_integration_status",
+    "wrap_asgi_application",
+]
+
+# Re-export for `from insider.integrations.django.asgi import ...`
+from .asgi import wrap_asgi_application  # noqa: E402

insider/integrations/django/asgi.py

@@ -0,0 +1,123 @@
+"""
+ASGI support for Django — escape capture and optional HTTP wrapper.
+
+`install()` patches `ASGIHandler` (mirrors `wsgi.install()`).
+
+`wrap_asgi_application()` wraps the HTTP branch of a Channels
+`ProtocolTypeRouter` (or plain `get_asgi_application()`). Use with
+`DjangoIntegration(auto_perf=False)` so footprints are not emitted twice.
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any, Callable, Dict, MutableMapping, Optional
+
+from ... import capture_exception
+from ...client import _client
+from ...safety import debug, safe
+from ...stacktrace import exception_payload
+from .perf import emit_http_footprint
+from .request import build_request_ctx_from_scope
+
+ASGIApp = Callable[..., Any]
+
+_handler_patched = False
+
+
+def install() -> None:
+    """Patch ASGIHandler to capture exceptions that escape Django entirely."""
+    global _handler_patched
+    if _handler_patched:
+        return
+    try:
+        from django.core.handlers.asgi import ASGIHandler
+    except ImportError:
+        debug("django ASGIHandler unavailable; skipping ASGI patch")
+        return
+
+    old_call = ASGIHandler.__call__
+
+    @safe
+    async def patched_call(
+        self: Any,
+        scope: MutableMapping[str, Any],
+        receive: Callable[..., Any],
+        send: Callable[..., Any],
+    ) -> Any:
+        if _client() is None:
+            return await old_call(self, scope, receive, send)
+        try:
+            return await old_call(self, scope, receive, send)
+        except BaseException as exc:
+            capture_exception(exc)
+            raise
+
+    ASGIHandler.__call__ = patched_call  # type: ignore[method-assign]
+    _handler_patched = True
+
+
+def wrap_asgi_application(application: ASGIApp) -> ASGIApp:
+    """
+    Wrap a Django (or other) ASGI HTTP app to emit one footprint per request.
+
+    Pass the return value of `get_asgi_application()` or the ``"http"`` branch
+    of a ``ProtocolTypeRouter``. Pair with ``DjangoIntegration(auto_perf=False)``.
+    """
+    return _InsiderAsgiHttpWrapper(application)
+
+
+class _InsiderAsgiHttpWrapper:
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(
+        self,
+        scope: MutableMapping[str, Any],
+        receive: Callable[..., Any],
+        send: Callable[..., Any],
+    ) -> None:
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+
+        client = _client()
+        if client is None:
+            await self.app(scope, receive, send)
+            return
+
+        trace_id = uuid.uuid4().hex
+        client.scope.set_trace_id(trace_id)
+        client.scope.set_request(
+            build_request_ctx_from_scope(scope, client.send_default_pii)
+        )
+
+        start = time.perf_counter()
+        status_code: Optional[int] = None
+
+        async def send_wrapper(message: Dict[str, Any]) -> None:
+            nonlocal status_code
+            if message.get("type") == "http.response.start":
+                status_code = int(message.get("status", 500))
+            await send(message)
+
+        try:
+            await self.app(scope, receive, send_wrapper)
+        except BaseException as exc:
+            block = exception_payload(
+                exc, in_app_include=client.scope.static.in_app_include
+            )
+            client.scope.set_pending_exception(block)
+            raise
+        finally:
+            path = str(scope.get("path") or "/")
+            method = str(scope.get("method") or "GET")
+            emit_http_footprint(
+                path=path,
+                method=method,
+                duration_ms=(time.perf_counter() - start) * 1000.0,
+                status_code=status_code,
+                trace_id=trace_id,
+            )
+            client.scope.clear_request_cycle()

insider/integrations/django/capture.py

@@ -16,6 +16,19 @@ from ...stacktrace import exception_payload
 from .request import build_request_ctx
 
 _CAPTURED_ATTR = "_insider_exception_captured"
+_PENDING_BLOCK_ATTR = "_insider_pending_exception_block"
+
+
+def sync_pending_from_request(request: Any) -> None:
+    """Copy exception buffered on the request (async worker thread) onto scope."""
+    client = _client()
+    if client is None:
+        return
+    if client.scope.current_pending_exception() is not None:
+        return
+    block = getattr(request, _PENDING_BLOCK_ATTR, None)
+    if block is not None:
+        client.scope.set_pending_exception(block)
 
 
 @safe
@@ -42,4 +55,5 @@ def capture_request_exception(request: Any, exception: BaseException) -> None:
     block = exception_payload(
         exception, in_app_include=client.scope.static.in_app_include
     )
+    setattr(request, _PENDING_BLOCK_ATTR, block)
     client.scope.set_pending_exception(block)

insider/integrations/django/handler.py

@@ -1,13 +1,17 @@
 """
-Patch `BaseHandler.get_response` for request context and auto perf timing.
+Patch `BaseHandler.get_response` / `get_response_async` for request context
+and auto perf timing.
 
-We patch `get_response` (not middleware) because:
+We patch the handler (not middleware) because:
 
-  - Customers already init in `wsgi.py` without touching INSTALLED_APPS.
+  - Customers already init in `wsgi.py` / `asgi.py` without touching INSTALLED_APPS.
   - The patch wraps the entire handler, including middleware inside Django's
     request cycle.
   - Perf timing in `finally` runs once per request whether the view returns
     200 or raises (converted to 500 by Django).
+
+Django 4.1+ ASGI uses `get_response_async` for the async request path
+(Daphne, `AsyncClient`). Both sync and async entrypoints are patched.
 """
 
 from __future__ import annotations
@@ -19,12 +23,39 @@ from typing import Any, Callable
 from ...client import _client
 from ...safety import debug, safe
 from .perf import emit_request_envelope
-from .request import build_request_ctx
+from .capture import sync_pending_from_request
 
 _patched = False
 _auto_perf = True
 
 
+def _finalize_request_cycle(
+    request: Any,
+    *,
+    start: float,
+    response: Any,
+    status_code: int | None,
+    trace_id: str,
+) -> None:
+    client = _client()
+    if client is None:
+        return
+    duration_ms = (time.perf_counter() - start) * 1000.0
+    if status_code is None and response is not None:
+        status_code = getattr(response, "status_code", None)
+    sync_pending_from_request(request)
+    if _auto_perf:
+        emit_request_envelope(
+            request,
+            duration_ms=duration_ms,
+            status_code=status_code,
+            trace_id=trace_id,
+        )
+        client.scope.clear_request_cycle()
+    # When auto_perf=False (e.g. wrap_asgi_application), leave scope intact
+    # for the outer ASGI wrapper to emit one combined footprint.
+
+
 def install(*, auto_perf: bool = True) -> None:
     global _patched, _auto_perf
     _auto_perf = auto_perf
@@ -37,6 +68,7 @@ def install(*, auto_perf: bool = True) -> None:
         return
 
     old_get_response = BaseHandler.get_response
+    old_get_response_async = BaseHandler.get_response_async
 
     @safe
     def patched_get_response(self: Any, request: Any) -> Any:
@@ -46,6 +78,8 @@ def install(*, auto_perf: bool = True) -> None:
 
         trace_id = uuid.uuid4().hex
         client.scope.set_trace_id(trace_id)
+        from .request import build_request_ctx
+
         ctx = build_request_ctx(request, client.send_default_pii)
         client.scope.set_request(ctx)
 
@@ -57,15 +91,43 @@ def install(*, auto_perf: bool = True) -> None:
             status_code = getattr(response, "status_code", None)
             return response
         finally:
-            duration_ms = (time.perf_counter() - start) * 1000.0
-            if _auto_perf:
-                emit_request_envelope(
-                    request,
-                    duration_ms=duration_ms,
-                    status_code=status_code,
-                    trace_id=trace_id,
-                )
-            client.scope.clear_request_cycle()
+            _finalize_request_cycle(
+                request,
+                start=start,
+                response=response,
+                status_code=status_code,
+                trace_id=trace_id,
+            )
+
+    @safe
+    async def patched_get_response_async(self: Any, request: Any) -> Any:
+        client = _client()
+        if client is None:
+            return await old_get_response_async(self, request)
+
+        trace_id = uuid.uuid4().hex
+        client.scope.set_trace_id(trace_id)
+        from .request import build_request_ctx
+
+        ctx = build_request_ctx(request, client.send_default_pii)
+        client.scope.set_request(ctx)
+
+        start = time.perf_counter()
+        response = None
+        status_code: int | None = None
+        try:
+            response = await old_get_response_async(self, request)
+            status_code = getattr(response, "status_code", None)
+            return response
+        finally:
+            _finalize_request_cycle(
+                request,
+                start=start,
+                response=response,
+                status_code=status_code,
+                trace_id=trace_id,
+            )
 
     BaseHandler.get_response = patched_get_response  # type: ignore[method-assign]
+    BaseHandler.get_response_async = patched_get_response_async  # type: ignore[method-assign]
     _patched = True

insider/integrations/django/perf.py

@@ -14,9 +14,10 @@ from ...safety import safe
 
 
 @safe
-def emit_request_envelope(
-    request: Any,
+def emit_http_footprint(
     *,
+    path: str,
+    method: Optional[str],
     duration_ms: float,
     status_code: Optional[int],
     trace_id: Optional[str],
@@ -26,9 +27,7 @@ def emit_request_envelope(
     if client is None:
         return
 
-    method = getattr(request, "method", None)
-    op = getattr(request, "path", None) or "unknown"
-
+    op = path or "unknown"
     client.capture_request(
         duration_ms=duration_ms,
         op=op,
@@ -36,3 +35,21 @@ def emit_request_envelope(
         method=method,
         trace_id=trace_id,
     )
+
+
+@safe
+def emit_request_envelope(
+    request: Any,
+    *,
+    duration_ms: float,
+    status_code: Optional[int],
+    trace_id: Optional[str],
+) -> None:
+    """Build and ship a single `kind=request` beacon from a Django request."""
+    emit_http_footprint(
+        path=getattr(request, "path", None) or "unknown",
+        method=getattr(request, "method", None),
+        duration_ms=duration_ms,
+        status_code=status_code,
+        trace_id=trace_id,
+    )

insider/integrations/django/request.py

@@ -39,6 +39,47 @@ def attach_drf_request_backref(django_request: Any, drf_request: Any) -> None:
         debug(f"drf request backref failed: {exc}")
 
 
+def build_request_ctx_from_scope(
+    scope: Any,
+    send_default_pii: bool,
+) -> Dict[str, Any]:
+    """Build request context from a raw ASGI HTTP scope."""
+    try:
+        headers: Dict[str, str] = {}
+        for key, value in scope.get("headers") or []:
+            try:
+                name = key.decode("latin-1").lower().replace("_", "-")
+                val = value.decode("latin-1")
+            except Exception:
+                continue
+            if name not in _SAFE_HEADERS and len(val) > 4096:
+                continue
+            headers[name] = val
+
+        query_raw = scope.get("query_string") or b""
+        query = (
+            query_raw.decode("latin-1", errors="replace") if query_raw else None
+        )
+        path = scope.get("path")
+        method = scope.get("method")
+        client = scope.get("client")
+        ip = client[0] if client else None
+
+        ctx: Dict[str, Any] = {
+            "method": method,
+            "path": path,
+            "query_string": query,
+            "headers": headers,
+            "ip": ip,
+        }
+        if send_default_pii and ip:
+            ctx["ip_address"] = ip
+        return ctx
+    except Exception as exc:
+        debug(f"asgi scope ctx build failed: {exc}")
+        return {}
+
+
 def build_request_ctx(request: Any, send_default_pii: bool) -> Dict[str, Any]:
     try:
         request = _resolve_drf_request(request)

insider/integrations/django/signals.py

@@ -1,30 +1,70 @@
 """
-Connect Django's `got_request_exception` signal to Insider capture.
+Connect Django's exception path to Insider capture.
+
+Patches ``response_for_exception`` so the exception object is captured
+reliably on both WSGI and ASGI (``got_request_exception`` alone is not
+enough — ``sys.exc_info()`` is often cleared before the signal handler runs).
 """
 
 from __future__ import annotations
 
 import sys
-from typing import Any
+from typing import Any, Tuple, Type
 
 from ...safety import debug, safe
 from .capture import capture_request_exception
 
 _connected = False
+_rfe_patched = False
+
+# These are converted to 4xx responses without emitting got_request_exception.
+_HANDLED_QUIETLY: Tuple[Type[BaseException], ...] = ()
 
 
 def install() -> None:
-    global _connected
-    if _connected:
+    global _connected, _rfe_patched, _HANDLED_QUIETLY
+    if _connected and _rfe_patched:
         return
     try:
         from django.core import signals
+        from django.core.exceptions import (
+            BadRequest,
+            PermissionDenied,
+            SuspiciousOperation,
+        )
+        from django.core.handlers import exception as exception_module
+        from django.http import Http404
+        from django.http.multipartparser import MultiPartParserError
     except ImportError:
-        debug("django signals unavailable; skipping got_request_exception hook")
+        debug("django signals unavailable; skipping exception hooks")
         return
 
-    signals.got_request_exception.connect(_on_got_request_exception)
-    _connected = True
+    _HANDLED_QUIETLY = (
+        Http404,
+        PermissionDenied,
+        MultiPartParserError,
+        BadRequest,
+        SuspiciousOperation,
+    )
+
+    if not _rfe_patched:
+        old_rfe = exception_module.response_for_exception
+
+        @safe
+        def patched_rfe(request: Any, exc: BaseException) -> Any:
+            response = old_rfe(request, exc)
+            if not isinstance(exc, _HANDLED_QUIETLY) and getattr(
+                response, "status_code", 500
+            ) >= 500:
+                capture_request_exception(request, exc)
+            return response
+
+        exception_module.response_for_exception = patched_rfe  # type: ignore[attr-defined]
+        _rfe_patched = True
+
+    if not _connected:
+        signals.got_request_exception.connect(_on_got_request_exception)
+        _connected = True
 
 
 @safe

insider/safety.py

@@ -50,6 +50,9 @@ def safe(fn: F) -> F:
     the boundary functions catch them.
     """
 
+    if asyncio_iscoroutinefunction(fn):
+        return safe_async(fn)  # type: ignore[return-value]
+
     @functools.wraps(fn)
     def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
@@ -59,3 +62,26 @@ def safe(fn: F) -> F:
             return None
 
     return wrapper  # type: ignore[return-value]
+
+
+def asyncio_iscoroutinefunction(fn: Any) -> bool:
+    try:
+        import asyncio
+
+        return asyncio.iscoroutinefunction(fn)
+    except Exception:
+        return False
+
+
+def safe_async(fn: F) -> F:
+    """Like `@safe` for async functions — preserves the coroutine contract."""
+
+    @functools.wraps(fn)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return await fn(*args, **kwargs)
+        except Exception as exc:
+            debug(f"swallowed {type(exc).__name__} in {fn.__qualname__}: {exc}")
+            return None
+
+    return wrapper  # type: ignore[return-value]

{insider_python-0.1.4.dist-info → insider_python-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: insider-python
-Version: 0.1.4
+Version: 0.3.0
 Summary: Python SDK for Insider — ship Beacons to your Insider server.
 Author: Insider
 License-Expression: MIT
@@ -70,7 +70,10 @@ Out-of-band events (background jobs, explicit calls) use standalone beacons:
 
 ### Django
 
-Initialize in `wsgi.py` (or `asgi.py`) before `get_wsgi_application()`:
+Initialize in `wsgi.py` or `asgi.py` **before** `get_wsgi_application()` /
+`get_asgi_application()`:
+
+#### WSGI (Gunicorn)
 
 ```python
 import os
@@ -78,6 +81,8 @@ import insider
 from insider.integrations.django import DjangoIntegration
 from insider.integrations.logging import LoggingIntegration
 
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")
+
 insider.init(
     dsn=os.environ.get("INSIDER_DSN"),
     environment="production",
@@ -90,6 +95,65 @@ from django.core.wsgi import get_wsgi_application
 application = get_wsgi_application()
 ```
 
+#### ASGI (Daphne / Uvicorn — plain Django)
+
+```python
+import os
+import insider
+from insider.integrations.django import DjangoIntegration
+from insider.integrations.logging import LoggingIntegration
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")
+
+insider.init(
+    dsn=os.environ.get("INSIDER_DSN"),
+    environment="production",
+    release="1.2.3",
+    enable_logs=True,
+    integrations=[DjangoIntegration(), LoggingIntegration()],
+)
+
+from django.core.asgi import get_asgi_application
+application = get_asgi_application()
+```
+
+#### ASGI + Channels (`ProtocolTypeRouter`)
+
+Wrap only the HTTP branch; disable handler auto-perf to avoid double capture:
+
+```python
+import os
+import django
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")
+
+import django
+
+django.setup()
+
+import insider
+from insider.integrations.django import DjangoIntegration
+from insider.integrations.django.asgi import wrap_asgi_application
+from insider.integrations.logging import LoggingIntegration
+
+insider.init(
+    dsn=os.environ.get("INSIDER_DSN"),
+    environment="production",
+    enable_logs=True,
+    integrations=[DjangoIntegration(auto_perf=False), LoggingIntegration()],
+)
+
+from channels.routing import ProtocolTypeRouter, URLRouter
+from django.core.asgi import get_asgi_application
+
+application = ProtocolTypeRouter({
+    "http": wrap_asgi_application(get_asgi_application()),
+    "websocket": URLRouter(websocket_urlpatterns),
+})
+```
+
+Set `INSIDER_DEBUG=true` to print which hooks installed at startup.
+
 That's the whole setup. **Every HTTP request** emits **one** `kind=request`
 beacon containing:
 

{insider_python-0.1.4.dist-info → insider_python-0.3.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 insider/__init__.py,sha256=5vkZk0y10671uwRx4bvZB05b6CNUsH5jYEsBSOoGiw0,1011
 insider/_envelope.py,sha256=g7VQh4fBRVStzU4n7E_3bxij_x_Kw3p_IaAo9Fh94RE,6690
 insider/_footprint.py,sha256=d123PGVSbmvy5uEXEfQ44h6-V28uGMWjiDBfVcc2Du8,2072
-insider/_version.py,sha256=U8iF9nQf84cNN1x6CZXSB-I7SAnu3eG05meavOEi67c,246
+insider/_version.py,sha256=UEiwKKTe6TALAXOWbaJXXvR3Tsia52swt986qSpnCig,246
 insider/client.py,sha256=Bn8f0JQ7igzTjyEyig2mctBzb-hUyIxut6wRJW-RYeI,22085
 insider/dsn.py,sha256=S8BbRhmKKKU1N6W8cpMSQoyDO_EuUJ1PkcjhGrrf5hw,3009
 insider/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-insider/safety.py,sha256=mtzzWLujuvmd24W2VtVcMGO_81GPBbB2tYuVqU2KsuI,1910
+insider/safety.py,sha256=OqvVbCLMDANzk7HmtPjr19CAzbi6FoX0fRbL6BOvJf8,2626
 insider/scope.py,sha256=k6FeNTKhkBjR7AwAfvWBTZ4BnvKMoe3OkSX55DgRiO8,6105
 insider/scrubbing.py,sha256=U8N3MS5VtDUNpIWN4PZ8bvrPqmjRRXq5hWGXxzoF5Gw,2853
 insider/stacktrace.py,sha256=tgdS9dQ-bVyz59_874BstuCYaP6rGn2k6HMo9sW8Ks8,5310
@@ -15,18 +15,19 @@ insider/contrib/django/__init__.py,sha256=UMGrJgVO-FqszZo9Cviw7oWS8PLdXVHt3hwXZ_
 insider/contrib/django/apps.py,sha256=Ct584Pa-S9I82omP3t_Xsn4NrdlqfoNf0eUN9xFa7Hs,2036
 insider/contrib/django/middleware.py,sha256=lX5sGDZw4rJ6gsNEcOpqHspkvzqilxTlUxOszQxwzpI,2077
 insider/integrations/__init__.py,sha256=Obf8BJS2kngbCeHCBPCik0jY30_F-sk3qHMCJ1heIFY,616
-insider/integrations/django/__init__.py,sha256=AIT4_mUUkQDBZzsSAmLAu38u_zZ705sJ1aj0FI4KJsA,1760
-insider/integrations/django/capture.py,sha256=X5X0_3Ruh3Qfnsr7BRJk5nPPW2UdsTUPMRAgXxTkhsA,1305
+insider/integrations/django/__init__.py,sha256=HhVeMP3erdA5TYStTIJv4nQN3aAVwjaUiooI-Jl2cF0,3830
+insider/integrations/django/asgi.py,sha256=s9eCAtGC45PDvS1yPhKr9I103aicSmjq83G2WpUW_Nk,3801
+insider/integrations/django/capture.py,sha256=22tea2oSFZQ03M4pKNKxTotoqXG9svi1QPbBP_20K4M,1818
 insider/integrations/django/drf.py,sha256=MXY4erP9gPBiEvf8Hi0CLrUBczXY1o7Y5wVCjSsQeCY,899
-insider/integrations/django/handler.py,sha256=AqkYyzpuILfAIi43QUdyVqEn0g0Oc64wWlE_WFaZEAc,2174
-insider/integrations/django/perf.py,sha256=2B0hvCQuuWQubDdGcAetF1pzkdTLvQWDDAxLwT-htDU,916
-insider/integrations/django/request.py,sha256=pOuQxnFWeA3KPAc0eVaRtkxGRyr2PetGKEg7OlTnqF4,4181
-insider/integrations/django/signals.py,sha256=kwH7npDG3AC9MILB9f4YUYofy5iwOosapGkBm_3dZY4,802
+insider/integrations/django/handler.py,sha256=04fH28hBJzDS5n2pmwZkkBA4is9Sk29rMCh_XjEWAK0,4154
+insider/integrations/django/perf.py,sha256=i5pp3Y3niw4MEFsdRdCOatyrhcxC1imunnePyBVq-xQ,1331
+insider/integrations/django/request.py,sha256=8XhzQgG9Zb2p8UFNt_XEyTDGX9ibSEBnC4WGJSv_XHE,5441
+insider/integrations/django/signals.py,sha256=KFyZ3A0_Jpp0461lAaB_PmsNMAKExQOy73vvRNbWUso,2271
 insider/integrations/django/wsgi.py,sha256=kJ5qo5LUdRYJtp4NkiD38DZzbb__idJU6FAltYhgtus,1044
 insider/integrations/logging/__init__.py,sha256=vjsVWFmC1j6v-ZIcWtOP24JkvbnmvgHYlgpYP2jwR4g,1805
 insider/integrations/logging/handler.py,sha256=s_RfCuVr02I9D6igzgju2vnx0x1qUENyVFtwP5eguFs,2019
 insider/integrations/logging/levels.py,sha256=yYkt_vhJLMigiCj0Bk7UYf3hWpYO90JMp-pvRdQSan8,646
-insider_python-0.1.4.dist-info/METADATA,sha256=CtXFkqSPjtWNkIOiUmNciPnTohQZ-Rri4EyWoPGvwxo,4690
-insider_python-0.1.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-insider_python-0.1.4.dist-info/top_level.txt,sha256=g_YKp2jCaaefmasZ2nOa9capm0X8q2sAWI_eEClKIos,8
-insider_python-0.1.4.dist-info/RECORD,,
+insider_python-0.3.0.dist-info/METADATA,sha256=NtDP6hxdo9FkCOOILKGd3fNKaER6QVg4PrQicFUtgPU,6346
+insider_python-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+insider_python-0.3.0.dist-info/top_level.txt,sha256=g_YKp2jCaaefmasZ2nOa9capm0X8q2sAWI_eEClKIos,8
+insider_python-0.3.0.dist-info/RECORD,,