bug-tracer-client 0.1.0__tar.gz

bug_tracer_client-0.1.0/.gitignore

@@ -0,0 +1,17 @@
+.env
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+.venv/
+db.sqlite3
+project/db.sqlite3
+project/test_db.sqlite3
+project/.pytest_cache/
+project/.coverage
+project/htmlcov/
+project/.venv/
+*.egg-info/

bug_tracer_client-0.1.0/LICENSE

@@ -0,0 +1,9 @@
+Proprietary License
+
+Copyright (c) Bug Tracer.
+
+All rights reserved.
+
+No permission is granted to use, copy, modify, distribute, sublicense,
+or publish this software except by explicit written agreement from the
+copyright holder.

bug_tracer_client-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: bug-tracer-client
+Version: 0.1.0
+Summary: Django middleware client for sending unhandled exceptions to Bug Tracer
+Project-URL: Homepage, https://gitlab.com/bug-tracer/bug-tracer-api
+Project-URL: Repository, https://gitlab.com/bug-tracer/bug-tracer-api
+Project-URL: Issues, https://gitlab.com/bug-tracer/bug-tracer-api/-/issues
+Author: Bug Tracer
+License: Proprietary
+License-File: LICENSE
+Keywords: bug-tracker,django,errors,monitoring
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.1
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: django<6.0,>=4.2
+Requires-Dist: requests<3.0.0,>=2.32.0
+Description-Content-Type: text/markdown
+
+# bug-tracer-client
+
+`bug-tracer-client` is a reusable Django app that captures unhandled exceptions and sends them to a Bug Tracer backend.
+
+## Installation
+
+```bash
+pip install bug-tracer-client
+```
+
+## Django setup
+
+Add the app to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "bug_tracer_client",
+]
+```
+
+Add the middleware after authentication middleware so authenticated user context can be included:
+
+```python
+MIDDLEWARE = [
+    # ...
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "bug_tracer_client.middleware.BugTracerMiddleware",
+]
+```
+
+Set the single required setting:
+
+```python
+BUG_TRACER_DSN = "bugtracer+https://PUBLIC_KEY@bug-tracer.example.com/1"
+```
+
+Supported DSN formats:
+
+- `bugtracer+https://<public_key>@<host>[:<port>]/<project_id>`
+- `bugtracer+http://<public_key>@<host>[:<port>]/<project_id>`
+
+## What it sends
+
+The middleware sends a best-effort JSON payload containing:
+
+- exception type and message
+- stacktrace frames
+- request method and path
+- optional authenticated user info
+
+Sensitive fields such as `password`, `token`, `authorization`, and `cookie` are redacted before sending.
+
+## Smoke check
+
+```python
+from bug_tracer_client import __version__
+
+print(__version__)
+```

bug_tracer_client-0.1.0/README.md

@@ -0,0 +1,60 @@
+# bug-tracer-client
+
+`bug-tracer-client` is a reusable Django app that captures unhandled exceptions and sends them to a Bug Tracer backend.
+
+## Installation
+
+```bash
+pip install bug-tracer-client
+```
+
+## Django setup
+
+Add the app to `INSTALLED_APPS`:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "bug_tracer_client",
+]
+```
+
+Add the middleware after authentication middleware so authenticated user context can be included:
+
+```python
+MIDDLEWARE = [
+    # ...
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "bug_tracer_client.middleware.BugTracerMiddleware",
+]
+```
+
+Set the single required setting:
+
+```python
+BUG_TRACER_DSN = "bugtracer+https://PUBLIC_KEY@bug-tracer.example.com/1"
+```
+
+Supported DSN formats:
+
+- `bugtracer+https://<public_key>@<host>[:<port>]/<project_id>`
+- `bugtracer+http://<public_key>@<host>[:<port>]/<project_id>`
+
+## What it sends
+
+The middleware sends a best-effort JSON payload containing:
+
+- exception type and message
+- stacktrace frames
+- request method and path
+- optional authenticated user info
+
+Sensitive fields such as `password`, `token`, `authorization`, and `cookie` are redacted before sending.
+
+## Smoke check
+
+```python
+from bug_tracer_client import __version__
+
+print(__version__)
+```

bug_tracer_client-0.1.0/bug_tracer_client/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.1.0"
+
+default_app_config = "bug_tracer_client.apps.BugTracerClientConfig"

bug_tracer_client-0.1.0/bug_tracer_client/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class BugTracerClientConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "bug_tracer_client"
+    verbose_name = "Bug Tracer Client"

bug_tracer_client-0.1.0/bug_tracer_client/client.py

@@ -0,0 +1,22 @@
+import requests
+
+from .conf import BugTracerSettings, get_bug_tracer_settings
+
+
+def send_event(payload: dict, config: BugTracerSettings | None = None, session=None) -> bool:
+    active_config = config or get_bug_tracer_settings()
+    if not active_config.parsed_dsn:
+        return False
+
+    http_client = session or requests
+    try:
+        response = http_client.post(
+            active_config.parsed_dsn.ingest_url,
+            json=payload,
+            headers={"X-Bug-Tracker-DSN": active_config.parsed_dsn.header_dsn},
+            timeout=active_config.timeout,
+        )
+    except requests.RequestException:
+        return False
+
+    return bool(getattr(response, "ok", False))

bug_tracer_client-0.1.0/bug_tracer_client/conf.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+
+from django.conf import settings
+
+from .dsn import ParsedBugTracerDsn, parse_bug_tracer_dsn
+
+DEFAULT_SENSITIVE_FIELDS = (
+    "password",
+    "passwd",
+    "secret",
+    "token",
+    "api_key",
+    "authorization",
+    "cookie",
+)
+DEFAULT_TIMEOUT = 1.0
+
+
+@dataclass(frozen=True)
+class BugTracerSettings:
+    parsed_dsn: ParsedBugTracerDsn | None
+    timeout: float
+    sensitive_fields: tuple[str, ...]
+
+
+def get_bug_tracer_settings() -> BugTracerSettings:
+    raw_dsn = getattr(settings, "BUG_TRACER_DSN", "")
+    try:
+        parsed_dsn = parse_bug_tracer_dsn(raw_dsn) if raw_dsn else None
+    except ValueError:
+        parsed_dsn = None
+
+    return BugTracerSettings(
+        parsed_dsn=parsed_dsn,
+        timeout=DEFAULT_TIMEOUT,
+        sensitive_fields=DEFAULT_SENSITIVE_FIELDS,
+    )

bug_tracer_client-0.1.0/bug_tracer_client/dsn.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+
+@dataclass(frozen=True)
+class ParsedBugTracerDsn:
+    ingest_url: str
+    header_dsn: str
+    public_key: str
+    host: str
+    project_id: str
+    transport: str
+
+
+def parse_bug_tracer_dsn(raw_dsn: str) -> ParsedBugTracerDsn:
+    if not raw_dsn:
+        raise ValueError("BUG_TRACER_DSN is empty")
+
+    parsed = urlsplit(raw_dsn)
+    transport = _parse_transport(parsed.scheme)
+    public_key = parsed.username
+    host = parsed.hostname
+    project_id = _parse_project_id(parsed.path)
+
+    if not public_key:
+        raise ValueError("BUG_TRACER_DSN public key is required")
+    if parsed.password:
+        raise ValueError("BUG_TRACER_DSN password is not supported")
+    if not host:
+        raise ValueError("BUG_TRACER_DSN host is required")
+    if parsed.query or parsed.fragment:
+        raise ValueError("BUG_TRACER_DSN query and fragment are not supported")
+
+    netloc = parsed.netloc.rsplit("@", 1)[-1]
+    ingest_url = f"{transport}://{netloc}/api/v1/ingest/"
+    header_dsn = f"bugtracer://{public_key}@{netloc}/{project_id}"
+    return ParsedBugTracerDsn(
+        ingest_url=ingest_url,
+        header_dsn=header_dsn,
+        public_key=public_key,
+        host=host,
+        project_id=project_id,
+        transport=transport,
+    )
+
+
+def _parse_transport(scheme: str) -> str:
+    if scheme not in {"bugtracer+http", "bugtracer+https"}:
+        raise ValueError("BUG_TRACER_DSN scheme must be bugtracer+http or bugtracer+https")
+    return scheme.removeprefix("bugtracer+")
+
+
+def _parse_project_id(path: str) -> str:
+    project_id = path.lstrip("/")
+    if not project_id or "/" in project_id:
+        raise ValueError("BUG_TRACER_DSN path must contain a single project id")
+    return project_id

bug_tracer_client-0.1.0/bug_tracer_client/filters.py

@@ -0,0 +1,34 @@
+from collections.abc import Mapping
+
+REDACTED = "[REDACTED]"
+
+
+def sanitize_data(value, sensitive_fields: tuple[str, ...]):
+    normalized_sensitive_fields = {normalize_key(field) for field in sensitive_fields}
+    return _sanitize_value(value, normalized_sensitive_fields)
+
+
+def _sanitize_value(value, sensitive_fields: set[str]):
+    if isinstance(value, Mapping):
+        return {
+            key: (
+                REDACTED
+                if is_sensitive_key(key, sensitive_fields)
+                else _sanitize_value(item, sensitive_fields)
+            )
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [_sanitize_value(item, sensitive_fields) for item in value]
+    if isinstance(value, tuple):
+        return tuple(_sanitize_value(item, sensitive_fields) for item in value)
+    return value
+
+
+def is_sensitive_key(key, sensitive_fields: set[str]) -> bool:
+    normalized_key = normalize_key(key)
+    return any(field and field in normalized_key for field in sensitive_fields)
+
+
+def normalize_key(key) -> str:
+    return "".join(ch.lower() for ch in str(key) if ch.isalnum())

bug_tracer_client-0.1.0/bug_tracer_client/middleware.py

@@ -0,0 +1,23 @@
+from .client import send_event
+from .conf import get_bug_tracer_settings
+from .payload import build_event_payload
+
+
+class BugTracerMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        try:
+            return self.get_response(request)
+        except Exception as exc:
+            self.capture_exception(request, exc)
+            raise
+
+    def capture_exception(self, request, exc: Exception) -> None:
+        config = get_bug_tracer_settings()
+        try:
+            payload = build_event_payload(request, exc, config)
+            send_event(payload, config=config)
+        except Exception:
+            return

bug_tracer_client-0.1.0/bug_tracer_client/payload.py

@@ -0,0 +1,97 @@
+import json
+import traceback
+from datetime import datetime, timezone
+
+from django.http import QueryDict
+
+from .conf import BugTracerSettings
+from .filters import sanitize_data
+
+
+def build_event_payload(request, exc: Exception, config: BugTracerSettings) -> dict:
+    payload = {
+        "message": str(exc) or exc.__class__.__name__,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "exception": {
+            "type": exc.__class__.__name__,
+            "value": str(exc),
+            "stacktrace": {"frames": extract_frames(exc)},
+        },
+        "request": build_request_payload(request),
+    }
+    user_payload = build_user_payload(request)
+    if user_payload:
+        payload["user"] = user_payload
+    return sanitize_data(payload, config.sensitive_fields)
+
+
+def extract_frames(exc: Exception) -> list[dict[str, object | None]]:
+    return [
+        {
+            "filename": frame.filename,
+            "function": frame.name,
+            "lineno": frame.lineno,
+            "context_line": frame.line,
+        }
+        for frame in traceback.extract_tb(exc.__traceback__)
+    ]
+
+
+def build_request_payload(request) -> dict:
+    payload = {
+        "method": request.method,
+        "path": request.path,
+        "headers": build_headers(request),
+    }
+    query_params = querydict_to_dict(request.GET)
+    if query_params:
+        payload["query_params"] = query_params
+    body_data = build_request_data(request)
+    if body_data is not None:
+        payload["data"] = body_data
+    return payload
+
+
+def build_headers(request) -> dict:
+    headers = {}
+    for key, value in request.META.items():
+        if key.startswith("HTTP_"):
+            header_name = key[5:].replace("_", "-").title()
+            headers[header_name] = value
+        elif key in {"CONTENT_TYPE", "CONTENT_LENGTH"}:
+            headers[key.replace("_", "-").title()] = value
+    return headers
+
+
+def build_request_data(request):
+    if request.content_type == "application/json":
+        raw_body = request.body.decode("utf-8", errors="replace").strip()
+        if not raw_body:
+            return None
+        try:
+            return json.loads(raw_body)
+        except json.JSONDecodeError:
+            return {"raw_body": raw_body}
+    if request.POST:
+        return querydict_to_dict(request.POST)
+    return None
+
+
+def build_user_payload(request) -> dict | None:
+    user = getattr(request, "user", None)
+    if not user or not getattr(user, "is_authenticated", False):
+        return None
+
+    payload = {"id": user.pk, "username": user.get_username()}
+    email = getattr(user, "email", "")
+    if email:
+        payload["email"] = email
+    return payload
+
+
+def querydict_to_dict(querydict: QueryDict) -> dict:
+    data = {}
+    for key in querydict.keys():
+        values = querydict.getlist(key)
+        data[key] = values if len(values) > 1 else values[0]
+    return data

bug_tracer_client-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling>=1.25.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bug-tracer-client"
+version = "0.1.0"
+description = "Django middleware client for sending unhandled exceptions to Bug Tracer"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Proprietary" }
+authors = [
+  { name = "Bug Tracer" }
+]
+keywords = ["django", "errors", "bug-tracker", "monitoring"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Framework :: Django",
+  "Framework :: Django :: 5.1",
+  "Intended Audience :: Developers",
+  "License :: Other/Proprietary License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+  "Django>=4.2,<6.0",
+  "requests>=2.32.0,<3.0.0",
+]
+
+[project.urls]
+Homepage = "https://gitlab.com/bug-tracer/bug-tracer-api"
+Repository = "https://gitlab.com/bug-tracer/bug-tracer-api"
+Issues = "https://gitlab.com/bug-tracer/bug-tracer-api/-/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["bug_tracer_client"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "bug_tracer_client",
+  "README.md",
+  "LICENSE",
+]