errorgap 0.1.0__py3-none-any.whl

errorgap/__init__.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .client import Client, DeliveryResult
+from .configuration import Configuration
+from .handlers import install_excepthook, uninstall_excepthook
+from .version import VERSION
+
+__all__ = [
+    "init",
+    "notify",
+    "flush",
+    "shutdown",
+    "configuration",
+    "client",
+    "Configuration",
+    "Client",
+    "DeliveryResult",
+    "VERSION",
+]
+
+_configuration = Configuration()
+_client = Client(_configuration)
+
+
+def init(
+    *,
+    endpoint: Optional[str] = None,
+    project_slug: Optional[str] = None,
+    project_id: Optional[str] = None,
+    api_key: Optional[str] = None,
+    environment: Optional[str] = None,
+    root_directory: Optional[str] = None,
+    async_: Optional[bool] = None,
+    filter_keys: Optional[tuple] = None,
+    logger: Optional[Any] = None,
+    capture_globals: bool = True,
+) -> None:
+    """Configure the SDK and install global error hooks.
+
+    Reads ``ERRORGAP_ENDPOINT``, ``ERRORGAP_PROJECT_SLUG``,
+    ``ERRORGAP_PROJECT_ID``, and ``ERRORGAP_API_KEY`` from the environment when
+    the matching keyword argument is omitted.
+    """
+    global _configuration, _client
+
+    overrides: Dict[str, Any] = {}
+    if endpoint is not None:
+        overrides["endpoint"] = endpoint
+    if project_slug is not None:
+        overrides["project_slug"] = project_slug
+    if project_id is not None:
+        overrides["project_id"] = project_id
+    if api_key is not None:
+        overrides["api_key"] = api_key
+    if environment is not None:
+        overrides["environment"] = environment
+    if root_directory is not None:
+        overrides["root_directory"] = root_directory
+    if async_ is not None:
+        overrides["async_"] = async_
+    if filter_keys is not None:
+        overrides["filter_keys"] = filter_keys
+    if logger is not None:
+        overrides["logger"] = logger
+
+    _configuration = Configuration(**overrides)
+    _client.configure(_configuration)
+
+    if capture_globals:
+        install_excepthook(_client)
+    else:
+        uninstall_excepthook()
+
+
+def notify(
+    exc: BaseException,
+    context: Optional[Dict[str, Any]] = None,
+    environment: Optional[Dict[str, Any]] = None,
+    session: Optional[Dict[str, Any]] = None,
+    params: Optional[Dict[str, Any]] = None,
+    sync: bool = False,
+) -> DeliveryResult:
+    return _client.notify(
+        exc,
+        context=context,
+        environment=environment,
+        session=session,
+        params=params,
+        sync=sync,
+    )
+
+
+def flush(timeout: Optional[float] = None) -> None:
+    _client.flush(timeout)
+
+
+def shutdown(timeout: Optional[float] = None) -> None:
+    _client.shutdown(timeout)
+
+
+def configuration() -> Configuration:
+    return _configuration
+
+
+def client() -> Client:
+    return _client

errorgap/backtrace.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import os
+import traceback
+from typing import Any, Dict, List, Optional
+
+
+def parse_backtrace(exc: BaseException, root_directory: str) -> List[Dict[str, Any]]:
+    frames: List[Dict[str, Any]] = []
+    tb_frames = traceback.extract_tb(exc.__traceback__)
+
+    for index, frame in enumerate(tb_frames):
+        file = frame.filename
+        frames.append(
+            {
+                "file": _relative_file(file, root_directory),
+                "line": frame.lineno,
+                "function": frame.name,
+                "in_app": _is_in_app(file, root_directory),
+                "index": index,
+            }
+        )
+
+    return frames
+
+
+def _relative_file(file: Optional[str], root: str) -> Optional[str]:
+    if not file:
+        return file
+    if not root:
+        return file
+    normalized = root if root.endswith(os.sep) else root + os.sep
+    if file.startswith(normalized):
+        return file[len(normalized):]
+    return file
+
+
+def _is_in_app(file: Optional[str], root: str) -> bool:
+    if not file or not root:
+        return False
+    if "site-packages" in file:
+        return False
+    if file.startswith("<"):
+        return False
+    return file.startswith(root)

errorgap/client.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import json
+import logging
+import queue
+import threading
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+from urllib import error as urlerror
+from urllib import request as urlrequest
+
+from .configuration import Configuration
+from .notice import build_notice
+from .version import VERSION
+
+
+@dataclass
+class DeliveryResult:
+    status: Optional[int] = None
+    body: Optional[str] = None
+    error: Optional[BaseException] = None
+    queued: bool = False
+
+    @property
+    def success(self) -> bool:
+        return self.error is None and self.status is not None and 200 <= self.status < 300
+
+
+class Client:
+    def __init__(self, configuration: Configuration):
+        self._configuration = configuration
+        self._queue: "queue.Queue[Optional[Dict[str, Any]]]" = queue.Queue()
+        self._worker: Optional[threading.Thread] = None
+        self._lock = threading.Lock()
+
+    def configure(self, configuration: Configuration) -> None:
+        self._configuration = configuration
+
+    @property
+    def configuration(self) -> Configuration:
+        return self._configuration
+
+    def notify(
+        self,
+        exc: BaseException,
+        context: Optional[Dict[str, Any]] = None,
+        environment: Optional[Dict[str, Any]] = None,
+        session: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        sync: bool = False,
+    ) -> DeliveryResult:
+        try:
+            self._configuration.validate()
+            notice = build_notice(
+                exc,
+                self._configuration,
+                context=context,
+                environment=environment,
+                session=session,
+                params=params,
+            )
+        except Exception as caught:  # noqa: BLE001 — SDK must not raise
+            self._log(caught)
+            return DeliveryResult(error=caught)
+
+        if sync or not self._configuration.async_:
+            return self.deliver(notice)
+
+        self._ensure_worker()
+        self._queue.put(notice)
+        return DeliveryResult(queued=True, status=202)
+
+    def deliver(self, notice: Dict[str, Any]) -> DeliveryResult:
+        url = _notices_url(self._configuration)
+        body = json.dumps(notice).encode("utf-8")
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": f"errorgap-python/{VERSION}",
+        }
+        if self._configuration.api_key:
+            headers["X-Errorgap-Project-Key"] = self._configuration.api_key
+
+        req = urlrequest.Request(url, data=body, method="POST", headers=headers)
+        try:
+            with urlrequest.urlopen(req, timeout=10) as response:
+                response_body = response.read().decode("utf-8", errors="replace")
+                return DeliveryResult(status=response.status, body=response_body)
+        except urlerror.HTTPError as http_err:
+            response_body = ""
+            try:
+                response_body = http_err.read().decode("utf-8", errors="replace")
+            except Exception:  # noqa: BLE001
+                pass
+            return DeliveryResult(status=http_err.code, body=response_body, error=http_err)
+        except Exception as caught:  # noqa: BLE001 — network/socket errors
+            self._log(caught)
+            return DeliveryResult(error=caught)
+
+    def flush(self, timeout: Optional[float] = None) -> None:
+        """Block until all queued notices have been delivered."""
+        with self._lock:
+            worker = self._worker
+        if worker is None:
+            return
+        self._queue.join() if timeout is None else _wait_join(self._queue, timeout)
+
+    def shutdown(self, timeout: Optional[float] = None) -> None:
+        """Flush and tear down the worker thread. Safe to call multiple times."""
+        with self._lock:
+            worker = self._worker
+            self._worker = None
+        if worker is None:
+            return
+        self.flush(timeout)
+        self._queue.put(None)
+        worker.join(timeout)
+
+    def _ensure_worker(self) -> None:
+        with self._lock:
+            if self._worker is not None and self._worker.is_alive():
+                return
+            self._worker = threading.Thread(
+                target=self._worker_loop, name="errorgap-delivery", daemon=True
+            )
+            self._worker.start()
+
+    def _worker_loop(self) -> None:
+        while True:
+            item = self._queue.get()
+            try:
+                if item is None:
+                    return
+                self.deliver(item)
+            finally:
+                self._queue.task_done()
+
+    def _log(self, exc: BaseException) -> None:
+        logger = self._configuration.get_logger()
+        if logger is None:
+            return
+        if isinstance(logger, logging.Logger):
+            logger.warning("[errorgap] %s: %s", exc.__class__.__name__, exc)
+        else:
+            try:
+                logger.warning(f"[errorgap] {exc.__class__.__name__}: {exc}")
+            except Exception:  # noqa: BLE001
+                pass
+
+
+def _notices_url(configuration: Configuration) -> str:
+    base = configuration.endpoint.rstrip("/")
+    return f"{base}/api/projects/{configuration.project_slug}/notices"
+
+
+def _wait_join(q: "queue.Queue[Any]", timeout: float) -> None:
+    """queue.Queue has no join-with-timeout. Poll for emptiness."""
+    import time
+
+    deadline = time.monotonic() + timeout
+    while q.unfinished_tasks > 0 and time.monotonic() < deadline:
+        time.sleep(0.01)

errorgap/configuration.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+DEFAULT_FILTER_KEYS = (
+    "password",
+    "password_confirmation",
+    "token",
+    "secret",
+    "api_key",
+    "authorization",
+    "cookie",
+)
+
+
+def _default_environment() -> str:
+    return os.environ.get("ERRORGAP_ENVIRONMENT") or os.environ.get("ENV") or "development"
+
+
+@dataclass
+class Configuration:
+    endpoint: str = field(
+        default_factory=lambda: os.environ.get("ERRORGAP_ENDPOINT", "http://127.0.0.1:3030")
+    )
+    project_slug: Optional[str] = field(
+        default_factory=lambda: os.environ.get("ERRORGAP_PROJECT_SLUG")
+    )
+    project_id: Optional[str] = field(
+        default_factory=lambda: os.environ.get("ERRORGAP_PROJECT_ID")
+    )
+    api_key: Optional[str] = field(default_factory=lambda: os.environ.get("ERRORGAP_API_KEY"))
+    environment: str = field(default_factory=_default_environment)
+    root_directory: str = field(default_factory=os.getcwd)
+    async_: bool = True
+    logger: Optional[logging.Logger] = None
+    filter_keys: tuple = DEFAULT_FILTER_KEYS
+    apm_enabled: bool = False
+    apm_sample_rate: float = 1.0
+
+    def validate(self) -> None:
+        if not self.project_slug or not str(self.project_slug).strip():
+            raise ValueError("Errorgap project_slug is required")
+
+    def get_logger(self) -> logging.Logger:
+        return self.logger or logging.getLogger("errorgap")

errorgap/django.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+from . import notify
+
+
+class ErrorgapMiddleware:
+    """Django middleware that reports unhandled exceptions to Errorgap.
+
+    Add ``"errorgap.django.ErrorgapMiddleware"`` to ``MIDDLEWARE``. Place it
+    early so it sees exceptions raised by inner middleware too.
+    """
+
+    def __init__(self, get_response: Callable[..., Any]):
+        self.get_response = get_response
+
+    def __call__(self, request: Any) -> Any:
+        return self.get_response(request)
+
+    def process_exception(self, request: Any, exception: BaseException) -> Optional[Any]:
+        notify(
+            exception,
+            sync=True,
+            context=_context(request),
+            environment=_environment(request),
+            session=_session(request),
+            params=_params(request),
+        )
+        # Returning None lets Django continue its exception handling chain.
+        return None
+
+
+def _context(request: Any) -> Dict[str, Any]:
+    try:
+        resolver = getattr(request, "resolver_match", None)
+        view_name = resolver.view_name if resolver else None
+    except Exception:  # noqa: BLE001
+        view_name = None
+    try:
+        url = request.build_absolute_uri()
+    except Exception:  # noqa: BLE001
+        url = getattr(request, "path", None)
+    return {
+        "url": url,
+        "component": view_name or getattr(request, "path", None),
+        "action": getattr(request, "method", None),
+    }
+
+
+def _environment(request: Any) -> Dict[str, Any]:
+    meta = getattr(request, "META", {}) or {}
+    return {
+        "method": getattr(request, "method", None),
+        "path": getattr(request, "path", None),
+        "query_string": meta.get("QUERY_STRING"),
+        "user_agent": meta.get("HTTP_USER_AGENT"),
+        "remote_addr": meta.get("REMOTE_ADDR"),
+    }
+
+
+def _session(request: Any) -> Dict[str, Any]:
+    try:
+        session = getattr(request, "session", None)
+        if session is None:
+            return {}
+        return dict(session.items())
+    except Exception:  # noqa: BLE001
+        return {}
+
+
+def _params(request: Any) -> Dict[str, Any]:
+    out: Dict[str, Any] = {}
+    try:
+        for key, value in (getattr(request, "GET", {}) or {}).items():
+            out[key] = value
+        post = getattr(request, "POST", None)
+        if post:
+            for key, value in post.items():
+                out[key] = value
+    except Exception:  # noqa: BLE001
+        return out
+    return out

errorgap/fastapi.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict
+
+from . import notify
+
+
+class ErrorgapMiddleware:
+    """Pure ASGI middleware that reports unhandled exceptions to Errorgap.
+
+    Usage::
+
+        from fastapi import FastAPI
+        from errorgap.fastapi import ErrorgapMiddleware
+
+        app = FastAPI()
+        app.add_middleware(ErrorgapMiddleware)
+    """
+
+    def __init__(self, app: Callable[..., Any]) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Dict[str, Any], receive: Callable, send: Callable) -> None:
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+
+        try:
+            await self.app(scope, receive, send)
+        except Exception as exc:
+            notify(
+                exc,
+                sync=True,
+                context=_context(scope),
+                environment=_environment(scope),
+            )
+            raise
+
+
+def _context(scope: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "url": _build_url(scope),
+        "component": scope.get("path"),
+        "action": scope.get("method"),
+    }
+
+
+def _environment(scope: Dict[str, Any]) -> Dict[str, Any]:
+    headers = {k.decode("latin1"): v.decode("latin1") for k, v in scope.get("headers", [])}
+    client = scope.get("client") or (None, None)
+    return {
+        "method": scope.get("method"),
+        "path": scope.get("path"),
+        "query_string": scope.get("query_string", b"").decode("utf-8", errors="replace"),
+        "user_agent": headers.get("user-agent"),
+        "remote_addr": client[0],
+    }
+
+
+def _build_url(scope: Dict[str, Any]) -> str:
+    scheme = scope.get("scheme", "http")
+    headers = dict(scope.get("headers", []))
+    host = headers.get(b"host", b"").decode("latin1") or "localhost"
+    path = scope.get("path", "/")
+    query = scope.get("query_string", b"").decode("utf-8", errors="replace")
+    suffix = f"?{query}" if query else ""
+    return f"{scheme}://{host}{path}{suffix}"

errorgap/filter.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable
+
+FILTERED = "[FILTERED]"
+
+
+def filter_params(params: Dict[str, Any], filter_keys: Iterable[str]) -> Dict[str, Any]:
+    lowered = tuple(k.lower() for k in filter_keys)
+    return _walk(params, lowered)
+
+
+def _walk(value: Dict[str, Any], lowered: tuple) -> Dict[str, Any]:
+    out: Dict[str, Any] = {}
+    for key, val in value.items():
+        if _is_sensitive(str(key), lowered):
+            out[key] = FILTERED
+        elif isinstance(val, dict):
+            out[key] = _walk(val, lowered)
+        else:
+            out[key] = val
+    return out
+
+
+def _is_sensitive(key: str, lowered: tuple) -> bool:
+    lk = key.lower()
+    return any(needle in lk for needle in lowered)

errorgap/flask.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from . import notify
+
+
+def init_app(app: Any) -> None:
+    """Register Errorgap with a Flask application.
+
+    Subscribes to Flask's ``got_request_exception`` signal so all unhandled
+    exceptions raised inside a request are reported.
+    """
+    try:
+        from flask import got_request_exception
+    except ImportError as exc:  # pragma: no cover
+        raise RuntimeError("Flask is required to use errorgap.flask.init_app") from exc
+
+    def _on_exception(sender: Any, exception: BaseException, **_: Any) -> None:
+        try:
+            from flask import request
+
+            ctx = _context(request)
+            env = _environment(request)
+            params = _params(request)
+        except Exception:  # noqa: BLE001
+            ctx, env, params = {}, {}, {}
+
+        notify(
+            exception,
+            sync=True,
+            context=ctx,
+            environment=env,
+            params=params,
+        )
+
+    # weak=False: keep a strong reference so the local closure isn't GC'd.
+    got_request_exception.connect(_on_exception, app, weak=False)
+
+
+def _context(request: Any) -> Dict[str, Any]:
+    return {
+        "url": getattr(request, "url", None),
+        "component": getattr(request, "endpoint", None) or getattr(request, "path", None),
+        "action": getattr(request, "method", None),
+    }
+
+
+def _environment(request: Any) -> Dict[str, Any]:
+    return {
+        "method": getattr(request, "method", None),
+        "path": getattr(request, "path", None),
+        "query_string": getattr(request, "query_string", b"").decode("utf-8", errors="replace")
+        if isinstance(getattr(request, "query_string", None), (bytes, bytearray))
+        else getattr(request, "query_string", None),
+        "user_agent": str(getattr(request, "user_agent", "") or ""),
+        "remote_addr": getattr(request, "remote_addr", None),
+    }
+
+
+def _params(request: Any) -> Dict[str, Any]:
+    out: Dict[str, Any] = {}
+    try:
+        for key, value in (getattr(request, "args", {}) or {}).items():
+            out[key] = value
+    except Exception:  # noqa: BLE001
+        pass
+    try:
+        form = getattr(request, "form", None)
+        if form:
+            for key, value in form.items():
+                out[key] = value
+    except Exception:  # noqa: BLE001
+        pass
+    try:
+        if request.is_json:
+            json_body = request.get_json(silent=True)
+            if isinstance(json_body, dict):
+                for key, value in json_body.items():
+                    out[key] = value
+    except Exception:  # noqa: BLE001
+        pass
+    return out

errorgap/handlers.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import sys
+from types import TracebackType
+from typing import Optional, Type
+
+from .client import Client
+
+_installed = False
+_previous_excepthook = None
+
+
+def install_excepthook(client: Client) -> None:
+    global _installed, _previous_excepthook
+    if _installed:
+        return
+    _previous_excepthook = sys.excepthook
+    _installed = True
+
+    def _hook(
+        exc_type: Type[BaseException],
+        exc: BaseException,
+        tb: Optional[TracebackType],
+    ) -> None:
+        try:
+            exc.__traceback__ = tb
+            client.notify(exc, sync=True, context={"source": "sys.excepthook"})
+        finally:
+            if _previous_excepthook is not None:
+                _previous_excepthook(exc_type, exc, tb)
+
+    sys.excepthook = _hook
+
+
+def uninstall_excepthook() -> None:
+    global _installed, _previous_excepthook
+    if not _installed:
+        return
+    sys.excepthook = _previous_excepthook or sys.__excepthook__
+    _previous_excepthook = None
+    _installed = False

errorgap/notice.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from .backtrace import parse_backtrace
+from .configuration import Configuration
+from .filter import filter_params
+from .version import VERSION
+
+
+def build_notice(
+    exc: BaseException,
+    configuration: Configuration,
+    context: Optional[Dict[str, Any]] = None,
+    environment: Optional[Dict[str, Any]] = None,
+    session: Optional[Dict[str, Any]] = None,
+    params: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    default_context: Dict[str, Any] = {
+        "notifier": "errorgap-python",
+        "notifier_version": VERSION,
+        "environment": configuration.environment,
+        "root_directory": configuration.root_directory,
+    }
+    if context:
+        default_context.update(context)
+
+    return {
+        "project_id": configuration.project_id,
+        "received_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+        "errors": [
+            {
+                "type": _error_type(exc),
+                "message": str(exc),
+                "backtrace": parse_backtrace(exc, configuration.root_directory),
+            }
+        ],
+        "context": default_context,
+        "environment": environment or {},
+        "session": session or {},
+        "params": filter_params(params or {}, configuration.filter_keys),
+    }
+
+
+def _error_type(exc: BaseException) -> str:
+    return exc.__class__.__name__

errorgap/version.py

@@ -0,0 +1 @@
+VERSION = "0.1.0"

errorgap-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: errorgap
+Version: 0.1.0
+Summary: Python notifier for Errorgap error tracking.
+Project-URL: Homepage, https://github.com/errorgaphq/errorgap-python
+Project-URL: Source, https://github.com/errorgaphq/errorgap-python
+Author: Errorgap
+License: MIT
+License-File: LICENSE
+Keywords: error-tracking,errorgap,exceptions,monitoring
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Bug Tracking
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: django>=4.2; extra == 'dev'
+Requires-Dist: fastapi>=0.100; extra == 'dev'
+Requires-Dist: flask>=2.3; extra == 'dev'
+Requires-Dist: httpx>=0.27; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: starlette>=0.27; extra == 'dev'
+Provides-Extra: django
+Requires-Dist: django>=4.2; extra == 'django'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100; extra == 'fastapi'
+Requires-Dist: starlette>=0.27; extra == 'fastapi'
+Provides-Extra: flask
+Requires-Dist: flask>=2.3; extra == 'flask'
+Description-Content-Type: text/markdown
+
+# errorgap
+
+Python notifier for [Errorgap](https://errorgap.com). Captures exceptions,
+normalizes tracebacks, and ships notices to an Errorgap server. Single
+package covers plain Python, Django, Flask, and FastAPI.
+
+## Install
+
+```sh
+pip install errorgap
+```
+
+For framework integrations:
+
+```sh
+pip install "errorgap[django]"   # or [flask], [fastapi]
+```
+
+Requires Python 3.9+.
+
+## Configure
+
+```python
+import errorgap
+
+errorgap.init(
+    endpoint=...,
+    project_slug=...,
+    api_key=...,
+    environment="production",
+)
+```
+
+`init` reads the same values from `ERRORGAP_ENDPOINT`,
+`ERRORGAP_PROJECT_SLUG`, `ERRORGAP_PROJECT_ID`, and `ERRORGAP_API_KEY` if you
+don't pass them. By default it installs a `sys.excepthook` to catch
+uncaught exceptions in scripts; pass `capture_globals=False` to skip.
+
+## Manual notification
+
+```python
+try:
+    risky()
+except Exception as exc:
+    errorgap.notify(exc, context={"component": "billing"})
+    raise
+```
+
+`notify` returns a `DeliveryResult` (`status`, `body`, `error`, `queued`).
+The SDK never raises.
+
+## Django
+
+Add to `MIDDLEWARE`:
+
+```python
+MIDDLEWARE = [
+    "errorgap.django.ErrorgapMiddleware",
+    # ... your existing middleware ...
+]
+```
+
+## Flask
+
+```python
+from flask import Flask
+from errorgap.flask import init_app
+
+app = Flask(__name__)
+init_app(app)
+```
+
+## FastAPI
+
+```python
+from fastapi import FastAPI
+from errorgap.fastapi import ErrorgapMiddleware
+
+app = FastAPI()
+app.add_middleware(ErrorgapMiddleware)
+```
+
+## Configuration reference
+
+| Argument | Default | Notes |
+|---|---|---|
+| `endpoint` | `ERRORGAP_ENDPOINT` or `http://127.0.0.1:3030` | Base URL, no trailing slash |
+| `project_slug` | `ERRORGAP_PROJECT_SLUG` | **Required** |
+| `project_id` | `ERRORGAP_PROJECT_ID` | Optional, embedded in payload |
+| `api_key` | `ERRORGAP_API_KEY` | Sent as `x-errorgap-project-key` |
+| `environment` | `ERRORGAP_ENVIRONMENT`, `ENV`, or `development` | |
+| `root_directory` | `os.getcwd()` | Used to mark frames as `in_app` |
+| `async_` | `True` | Background-thread delivery |
+| `logger` | `logging.getLogger("errorgap")` | Pass `None` to silence |
+| `filter_keys` | `("password", "token", ...)` | Substring match, case-insensitive |
+| `capture_globals` | `True` | Install `sys.excepthook` |
+
+## Graceful shutdown
+
+```python
+errorgap.flush(timeout=5)     # wait for queued deliveries
+errorgap.shutdown(timeout=5)  # flush + tear down background thread
+```
+
+## Verify
+
+```sh
+curl -sS -X POST "$ERRORGAP_ENDPOINT/api/projects/$ERRORGAP_PROJECT_SLUG/notices" \
+  -H "content-type: application/json" \
+  -H "x-errorgap-project-key: $ERRORGAP_API_KEY" \
+  -d '{"errors":[{"type":"ErrorgapInstallTest","message":"Errorgap install verification"}],"context":{"environment":"development"}}'
+```
+
+Then trigger a real error and confirm it appears in the Errorgap UI.
+
+## Development
+
+```sh
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT.

errorgap-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+errorgap/__init__.py,sha256=sPT-p-7L5tH9Js5JD4s3hDQPQWWbPIGt0jM8tI2VSIk,2801
+errorgap/backtrace.py,sha256=6728DCVjvxOBYcp8v_zIq2D7OUnNnxOaJyzsx1X4N84,1224
+errorgap/client.py,sha256=gn9KJUpGv_66DxZrEv-ABxGKh6yL0P7SUE5uSPq5_Gw,5537
+errorgap/configuration.py,sha256=kEvybDZMdQ-Eq5EJ9QcMnsy9hMkT7R1qP-OsGIZpshc,1475
+errorgap/django.py,sha256=xs6HLVsxzcsXQNiTpxy_NjaApGXCSQfgtMbXzYWSLzU,2514
+errorgap/fastapi.py,sha256=W_sHvMLb9vNRK74sk8XyA85UWsOO9FciNLfPJAXVrJI,2017
+errorgap/filter.py,sha256=kAvjCocwAJHI0u0DVSbQtBInbBGqebzz4fd2jbrHhb8,750
+errorgap/flask.py,sha256=CoYEXdGZy8aGkhN-AIOtJPVKuco3624uX0m_t6BVDHQ,2650
+errorgap/handlers.py,sha256=WOkKxxy2LguF1BU-VfVAecGSdLERgjRWCFj4Kz1p8M4,1033
+errorgap/notice.py,sha256=uRj1aQKu9GWvOlkAw-6zuQGQV3i3xKIqbxR2LRT2VbY,1468
+errorgap/version.py,sha256=CpXi3jGlx23RvRyU7iytOMZrnspdWw4yofS8lpP1AJU,18
+errorgap-0.1.0.dist-info/METADATA,sha256=nQJx_mVjp8vfE36JnjvuvC7HuEtZ3sX7KvmzIHF4cDc,4364
+errorgap-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+errorgap-0.1.0.dist-info/licenses/LICENSE,sha256=_skACZib1dUUS61LlXEDHa5ZgW6SBrScsIIJjbgTC0c,1065
+errorgap-0.1.0.dist-info/RECORD,,

errorgap-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

errorgap-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Errorgap
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.