autotrace-py 0.1.0__tar.gz

autotrace_py-0.1.0/MANIFEST.in

@@ -0,0 +1,8 @@
+include README.md
+include pyproject.toml
+recursive-include autotrace *.py
+
+global-exclude *.py[cod] __pycache__ *.so *.dylib .DS_Store
+global-exclude test_*.py *_test.py tests/*
+global-exclude .env* *.env
+global-exclude *.log

autotrace_py-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: autotrace-py
+Version: 0.1.0
+Summary: AutoTrace Python SDK for autonomous error tracking and AI triage
+Author-email: AutoTrace Team <maintainers@autotrace.io>
+License: MIT
+Project-URL: Homepage, https://autotrace.io
+Project-URL: Repository, https://github.com/autotrace/autotrace-py
+Project-URL: Documentation, https://docs.autotrace.io
+Keywords: error-tracking,ai-triage,gemini,monitoring,exceptions
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: System :: Monitoring
+Classifier: Topic :: Software Development :: Bug Tracking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: django
+Requires-Dist: django>=3.2; extra == "django"
+Provides-Extra: fastapi
+Requires-Dist: starlette>=0.14.0; extra == "fastapi"
+
+# AutoTrace Python SDK (`autotrace-py`)
+
+Lightweight, zero-dependency Python client for autonomous error tracking and AI triage with [AutoTrace](https://autotrace.io).
+
+## Installation
+
+```bash
+pip install autotrace
+# or from source:
+pip install -e ./sdk/python
+```
+
+## Quickstart
+
+```python
+import autotrace
+
+# 1. Initialize once at application startup
+autotrace.init(
+    api_key="<YOUR_API_KEY>",
+    endpoint_url="http://localhost:8000/api/ingest/",
+    environment="production",
+    context={"service": "payment-api", "version": "2.1.0"},
+)
+
+# 2. Manual Exception Capture
+try:
+    process_order()
+except Exception as exc:
+    autotrace.capture_exception(
+        exc_info=exc,
+        endpoint="/api/v1/orders",
+        context={"user_id": "usr_123"},
+    )
+```
+
+## Function Decorator
+
+```python
+@autotrace.trace(endpoint="/jobs/sync-inventory")
+def sync_inventory():
+    # If this raises, AutoTrace captures the error and traceback
+    perform_risky_task()
+```
+
+## Framework Integrations
+
+### Django
+
+In your `settings.py`:
+```python
+AUTOTRACE_API_KEY = "<YOUR_API_KEY>"
+AUTOTRACE_ENDPOINT = "http://localhost:8000/api/ingest/"
+
+MIDDLEWARE = [
+    # ... other middleware
+    "autotrace.integrations.django.AutoTraceMiddleware",
+]
+```
+
+### FastAPI / Starlette
+
+In your `main.py`:
+```python
+from fastapi import FastAPI
+import autotrace
+from autotrace.integrations.fastapi import AutoTraceMiddleware
+
+autotrace.init(api_key="<YOUR_API_KEY>")
+
+app = FastAPI()
+app.add_middleware(AutoTraceMiddleware)
+```

autotrace_py-0.1.0/README.md

@@ -0,0 +1,73 @@
+# AutoTrace Python SDK (`autotrace-py`)
+
+Lightweight, zero-dependency Python client for autonomous error tracking and AI triage with [AutoTrace](https://autotrace.io).
+
+## Installation
+
+```bash
+pip install autotrace
+# or from source:
+pip install -e ./sdk/python
+```
+
+## Quickstart
+
+```python
+import autotrace
+
+# 1. Initialize once at application startup
+autotrace.init(
+    api_key="<YOUR_API_KEY>",
+    endpoint_url="http://localhost:8000/api/ingest/",
+    environment="production",
+    context={"service": "payment-api", "version": "2.1.0"},
+)
+
+# 2. Manual Exception Capture
+try:
+    process_order()
+except Exception as exc:
+    autotrace.capture_exception(
+        exc_info=exc,
+        endpoint="/api/v1/orders",
+        context={"user_id": "usr_123"},
+    )
+```
+
+## Function Decorator
+
+```python
+@autotrace.trace(endpoint="/jobs/sync-inventory")
+def sync_inventory():
+    # If this raises, AutoTrace captures the error and traceback
+    perform_risky_task()
+```
+
+## Framework Integrations
+
+### Django
+
+In your `settings.py`:
+```python
+AUTOTRACE_API_KEY = "<YOUR_API_KEY>"
+AUTOTRACE_ENDPOINT = "http://localhost:8000/api/ingest/"
+
+MIDDLEWARE = [
+    # ... other middleware
+    "autotrace.integrations.django.AutoTraceMiddleware",
+]
+```
+
+### FastAPI / Starlette
+
+In your `main.py`:
+```python
+from fastapi import FastAPI
+import autotrace
+from autotrace.integrations.fastapi import AutoTraceMiddleware
+
+autotrace.init(api_key="<YOUR_API_KEY>")
+
+app = FastAPI()
+app.add_middleware(AutoTraceMiddleware)
+```

autotrace_py-0.1.0/autotrace/__init__.py

@@ -0,0 +1,27 @@
+"""
+AutoTrace Python SDK (autotrace-py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Autonomous error tracking and AI-powered incident triage.
+"""
+
+from autotrace.client import (
+    AutoTraceClient,
+    capture_exception,
+    flush,
+    get_client,
+    init,
+    sanitize_data,
+    trace,
+)
+
+__all__ = [
+    "init",
+    "capture_exception",
+    "trace",
+    "flush",
+    "get_client",
+    "AutoTraceClient",
+    "sanitize_data",
+]
+
+__version__ = "0.1.0"

autotrace_py-0.1.0/autotrace/client.py

@@ -0,0 +1,318 @@
+"""
+AutoTrace Python SDK Client (autotrace-py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Lightweight, zero-dependency client for capturing and reporting
+application exceptions asynchronously to the AutoTrace backend.
+"""
+
+from __future__ import annotations
+
+import atexit
+import json
+import logging
+import os
+import platform
+import queue
+import re
+import sys
+import threading
+import traceback
+import urllib.error
+import urllib.request
+from datetime import datetime, timezone
+from functools import wraps
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+logger = logging.getLogger("autotrace")
+
+# ---------------------------------------------------------------------------
+# Constants & Defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_ENDPOINT = "http://localhost:8000/api/ingest/"
+DEFAULT_ENVIRONMENT = "production"
+TIMEOUT_SECONDS = 5.0
+
+SENSITIVE_PATTERNS = re.compile(
+    r"(password|secret|token|authorization|api_key|access_token)", re.IGNORECASE
+)
+MASK_VALUE = "********"
+
+
+# ---------------------------------------------------------------------------
+# Data Sanitization
+# ---------------------------------------------------------------------------
+
+def _is_sensitive(key: str) -> bool:
+    return bool(SENSITIVE_PATTERNS.search(str(key)))
+
+
+def sanitize_data(data: Any) -> Any:
+    """Recursively scrub sensitive keys in dictionaries and lists."""
+    if isinstance(data, dict):
+        return {
+            k: (MASK_VALUE if _is_sensitive(k) else sanitize_data(v))
+            for k, v in data.items()
+        }
+    elif isinstance(data, (list, tuple)):
+        return [sanitize_data(item) for item in data]
+    return data
+
+
+# ---------------------------------------------------------------------------
+# AutoTrace Client
+# ---------------------------------------------------------------------------
+
+class AutoTraceClient:
+    """Core SDK client managing asynchronous dispatch of error events."""
+
+    def __init__(
+        self,
+        api_key: str,
+        endpoint_url: str = DEFAULT_ENDPOINT,
+        environment: str = DEFAULT_ENVIRONMENT,
+        default_context: Optional[Dict[str, Any]] = None,
+        max_queue_size: int = 1000,
+    ) -> None:
+        self.api_key = api_key.strip()
+        self.endpoint_url = endpoint_url
+        self.environment = environment
+        self.default_context = default_context or {}
+
+        # Asynchronous background worker queue
+        self._queue: queue.Queue = queue.Queue(maxsize=max_queue_size)
+        self._worker_thread = threading.Thread(
+            target=self._worker_loop,
+            daemon=True,
+            name="autotrace-worker",
+        )
+        self._worker_thread.start()
+
+        # Register exit handler to flush pending events
+        atexit.register(self.flush)
+
+    def _worker_loop(self) -> None:
+        """Background daemon thread that consumes and dispatches events."""
+        while True:
+            try:
+                payload, callback = self._queue.get()
+                if payload is None:
+                    # Poison pill to shut down worker if needed
+                    self._queue.task_done()
+                    break
+                status_code, response_data = self._send_http(payload)
+                if callback:
+                    callback(status_code, response_data)
+                self._queue.task_done()
+            except Exception as exc:
+                logger.debug("AutoTrace worker encountered an error (suppressed): %s", exc)
+
+    def _send_http(self, payload: Dict[str, Any]) -> Tuple[int, Optional[Dict[str, Any]]]:
+        """Perform a blocking HTTP POST with a short timeout. Fails silently."""
+        try:
+            body = json.dumps(payload).encode("utf-8")
+            req = urllib.request.Request(
+                self.endpoint_url,
+                data=body,
+                headers={
+                    "Content-Type": "application/json",
+                    "X-API-Key": self.api_key,
+                    "User-Agent": f"autotrace-py/0.1.0 (Python {platform.python_version()})",
+                },
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=TIMEOUT_SECONDS) as resp:
+                status_code = resp.status
+                resp_text = resp.read().decode("utf-8", errors="replace")
+                try:
+                    data = json.loads(resp_text)
+                except Exception:
+                    data = {"raw": resp_text}
+                logger.debug("AutoTrace: event reported (HTTP %s)", status_code)
+                return status_code, data
+        except urllib.error.HTTPError as exc:
+            err_body = exc.read().decode("utf-8", errors="replace")
+            logger.debug("AutoTrace: API error HTTP %s: %s", exc.code, err_body)
+            return exc.code, {"error": err_body}
+        except Exception as exc:
+            logger.debug("AutoTrace: delivery failed (suppressed): %s", exc)
+            return 0, {"error": str(exc)}
+
+    def capture_exception(
+        self,
+        exc_info: Optional[Union[BaseException, Tuple[Any, ...], bool]] = None,
+        context: Optional[Dict[str, Any]] = None,
+        endpoint: Optional[str] = None,
+        sync: bool = False,
+        callback: Optional[Callable[[int, Optional[Dict[str, Any]]], None]] = None,
+    ) -> Optional[Tuple[int, Optional[Dict[str, Any]]]]:
+        """Capture and format an unhandled exception for AutoTrace ingestion."""
+        # 1. Resolve exception details
+        if exc_info is True or exc_info is None:
+            exc_type, exc_val, exc_tb = sys.exc_info()
+        elif isinstance(exc_info, BaseException):
+            exc_type, exc_val, exc_tb = type(exc_info), exc_info, exc_info.__traceback__
+        elif isinstance(exc_info, tuple) and len(exc_info) == 3:
+            exc_type, exc_val, exc_tb = exc_info
+        else:
+            exc_type, exc_val, exc_tb = None, None, None
+
+        if exc_val is None:
+            logger.debug("AutoTrace: capture_exception called with no active exception.")
+            return None
+
+        # 2. Format traceback array
+        tb_lines: List[str] = []
+        try:
+            raw_lines = traceback.format_exception(exc_type, exc_val, exc_tb)
+            for chunk in raw_lines:
+                tb_lines.extend(chunk.splitlines())
+        except Exception:
+            tb_lines = [f"{exc_type}: {exc_val}"]
+
+        # 3. Assemble runtime metadata
+        runtime_str = f"python {platform.python_version()}"
+
+        # 4. Merge context
+        merged_context: Dict[str, Any] = {
+            **self.default_context,
+            "environment": self.environment,
+            "os": f"{platform.system()} {platform.release()}",
+            "architecture": platform.machine(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        }
+        if context:
+            merged_context.update(context)
+
+        # 5. Build universal ingestion payload
+        payload = {
+            "error_type": exc_type.__name__ if exc_type else "Exception",
+            "error_message": str(exc_val),
+            "endpoint": endpoint or "",
+            "runtime": runtime_str,
+            "traceback": tb_lines,
+            "context": sanitize_data(merged_context),
+        }
+
+        # 6. Dispatch synchronously or queue for background thread
+        if sync:
+            return self._send_http(payload)
+
+        try:
+            self._queue.put_nowait((payload, callback))
+        except queue.Full:
+            logger.warning("AutoTrace: event queue is full, dropping error event.")
+
+        return None
+
+    def trace(
+        self,
+        endpoint: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+        reraise: bool = False,
+    ) -> Callable:
+        """Decorator to automatically catch and report unhandled errors."""
+        def decorator(func: Callable) -> Callable:
+            @wraps(func)
+            def wrapper(*args: Any, **kwargs: Any) -> Any:
+                try:
+                    return func(*args, **kwargs)
+                except Exception as exc:
+                    self.capture_exception(
+                        exc_info=exc,
+                        endpoint=endpoint or func.__qualname__,
+                        context=context,
+                    )
+                    if reraise:
+                        raise
+                    return None
+            return wrapper
+        return decorator
+
+    def flush(self, timeout: float = 3.0) -> None:
+        """Block until all queued events are sent, up to *timeout* seconds."""
+        try:
+            self._queue.join()
+        except Exception:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# Global Singleton Interface
+# ---------------------------------------------------------------------------
+
+_GLOBAL_CLIENT: Optional[AutoTraceClient] = None
+
+
+def init(
+    api_key: str,
+    endpoint_url: str = DEFAULT_ENDPOINT,
+    environment: str = DEFAULT_ENVIRONMENT,
+    context: Optional[Dict[str, Any]] = None,
+) -> AutoTraceClient:
+    """Initialize the global AutoTrace client singleton."""
+    global _GLOBAL_CLIENT
+    _GLOBAL_CLIENT = AutoTraceClient(
+        api_key=api_key,
+        endpoint_url=endpoint_url,
+        environment=environment,
+        default_context=context,
+    )
+    logger.debug("AutoTrace SDK initialized for environment '%s'.", environment)
+    return _GLOBAL_CLIENT
+
+
+def get_client() -> Optional[AutoTraceClient]:
+    """Retrieve the global AutoTrace client instance."""
+    return _GLOBAL_CLIENT
+
+
+def capture_exception(
+    exc_info: Optional[Union[BaseException, Tuple[Any, ...], bool]] = None,
+    context: Optional[Dict[str, Any]] = None,
+    endpoint: Optional[str] = None,
+    sync: bool = False,
+    callback: Optional[Callable[[int, Optional[Dict[str, Any]]], None]] = None,
+) -> Optional[Tuple[int, Optional[Dict[str, Any]]]]:
+    """Capture an exception with the global client."""
+    if _GLOBAL_CLIENT is None:
+        logger.warning("AutoTrace SDK is not initialized. Call autotrace.init(...) first.")
+        return None
+    return _GLOBAL_CLIENT.capture_exception(
+        exc_info=exc_info,
+        context=context,
+        endpoint=endpoint,
+        sync=sync,
+        callback=callback,
+    )
+
+
+def trace(
+    endpoint: Optional[str] = None,
+    context: Optional[Dict[str, Any]] = None,
+    reraise: bool = False,
+) -> Callable:
+    """Decorator to catch and report exceptions using the global client."""
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return func(*args, **kwargs)
+            except Exception as exc:
+                if _GLOBAL_CLIENT:
+                    _GLOBAL_CLIENT.capture_exception(
+                        exc_info=exc,
+                        endpoint=endpoint or func.__qualname__,
+                        context=context,
+                    )
+                if reraise:
+                    raise
+                return None
+        return wrapper
+    return decorator
+
+
+def flush(timeout: float = 3.0) -> None:
+    """Flush pending events queued in the global client."""
+    if _GLOBAL_CLIENT:
+        _GLOBAL_CLIENT.flush(timeout=timeout)

autotrace_py-0.1.0/autotrace/integrations/__init__.py

@@ -0,0 +1 @@
+"""AutoTrace framework integrations."""

autotrace_py-0.1.0/autotrace/integrations/django.py

@@ -0,0 +1,77 @@
+"""
+AutoTrace Django Integration Middleware
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Captures unhandled exceptions during Django request handling and reports
+them to AutoTrace with sanitized request metadata and telemetry.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Callable, Dict, Optional
+
+from autotrace.client import capture_exception, init, get_client
+
+
+class AutoTraceMiddleware:
+    """Django middleware to automatically report unhandled exceptions."""
+
+    def __init__(self, get_response: Optional[Callable] = None) -> None:
+        self.get_response = get_response
+
+        # Auto-initialize if settings.AUTOTRACE_API_KEY is configured
+        try:
+            from django.conf import settings
+            if get_client() is None and hasattr(settings, "AUTOTRACE_API_KEY"):
+                init(
+                    api_key=settings.AUTOTRACE_API_KEY,
+                    endpoint_url=getattr(settings, "AUTOTRACE_ENDPOINT", "http://localhost:8000/api/ingest/"),
+                    environment=getattr(settings, "AUTOTRACE_ENVIRONMENT", "production"),
+                )
+        except Exception:
+            pass
+
+    def __call__(self, request: Any) -> Any:
+        try:
+            response = self.get_response(request) if self.get_response else None
+            return response
+        except Exception as exc:
+            self.process_exception(request, exc)
+            raise
+
+    def process_exception(self, request: Any, exception: BaseException) -> None:
+        """Capture request telemetry and dispatch error event to AutoTrace."""
+        headers: Dict[str, str] = {}
+        for key, value in getattr(request, "META", {}).items():
+            if key.startswith("HTTP_"):
+                header_name = key[5:].replace("_", "-").title()
+                headers[header_name] = str(value)
+            elif key in ("CONTENT_TYPE", "CONTENT_LENGTH", "REMOTE_ADDR"):
+                headers[key.replace("_", "-").title()] = str(value)
+
+        # Parse request query params
+        query_params = dict(getattr(request, "GET", {}).items())
+
+        # Best-effort parse body payload
+        body_data: Any = None
+        try:
+            raw_body = getattr(request, "body", None)
+            if raw_body:
+                body_data = json.loads(raw_body.decode("utf-8"))
+        except Exception:
+            pass
+
+        context: Dict[str, Any] = {
+            "method": getattr(request, "method", "UNKNOWN"),
+            "path": getattr(request, "path", ""),
+            "headers": headers,
+            "query_params": query_params,
+            "body": body_data,
+            "user": str(getattr(request, "user", "anonymous")),
+        }
+
+        capture_exception(
+            exc_info=exception,
+            endpoint=getattr(request, "path", ""),
+            context=context,
+        )

autotrace_py-0.1.0/autotrace/integrations/fastapi.py

@@ -0,0 +1,55 @@
+"""
+AutoTrace FastAPI / Starlette Integration Middleware
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ASGI middleware that intercepts unhandled exceptions in FastAPI / Starlette
+applications, captures route & header metadata, and reports them to AutoTrace.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict
+
+from autotrace.client import capture_exception
+
+
+class AutoTraceMiddleware:
+    """ASGI middleware for FastAPI and Starlette applications."""
+
+    def __init__(self, app: Callable) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Dict[str, Any], receive: Callable, send: Callable) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        try:
+            await self.app(scope, receive, send)
+        except Exception as exc:
+            # Extract headers from ASGI scope
+            headers: Dict[str, str] = {}
+            for raw_k, raw_v in scope.get("headers", []):
+                k = raw_k.decode("latin1").lower()
+                v = raw_v.decode("latin1")
+                headers[k] = v
+
+            endpoint = scope.get("path", "")
+            method = scope.get("method", "GET")
+            query_string = scope.get("query_string", b"").decode("latin1")
+
+            context = {
+                "method": method,
+                "path": endpoint,
+                "query_string": query_string,
+                "headers": headers,
+                "client": scope.get("client"),
+                "server": scope.get("server"),
+            }
+
+            capture_exception(
+                exc_info=exc,
+                endpoint=endpoint,
+                context=context,
+            )
+            # Re-raise so FastAPI's error handlers / status responses continue
+            raise

autotrace_py-0.1.0/autotrace/middleware.py

@@ -0,0 +1,284 @@
+"""
+AutoTrace Django Middleware — Client SDK
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Drop-in Django middleware that captures unhandled exceptions and reports
+them to the AutoTrace ingestion API.
+
+Quick start
+-----------
+1.  ``pip install autotrace``  (or add this package to your requirements)
+
+2.  Add to your Django settings::
+
+        MIDDLEWARE = [
+            ...
+            'autotrace.middleware.AutoTraceMiddleware',
+        ]
+
+        AUTOTRACE_DSN = "https://api.autotrace.io/ingest/"  # default
+        AUTOTRACE_API_KEY = "<your-project-api-key>"
+ 
+3.  That's it — unhandled 500s are now reported automatically.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import traceback
+from datetime import datetime, timezone
+from typing import Any, Callable
+
+from django.conf import settings
+from django.http import HttpRequest, HttpResponse
+
+try:
+    import urllib.request
+    import urllib.error
+
+    _HAS_URLLIB = True
+except ImportError:  # pragma: no cover — paranoia guard
+    _HAS_URLLIB = False
+
+logger = logging.getLogger("autotrace.middleware")
+
+# ---------------------------------------------------------------------------
+# Configuration helpers
+# ---------------------------------------------------------------------------
+
+# Default ingestion endpoint
+_DEFAULT_DSN = "https://api.autotrace.io/ingest/"
+
+# Maximum traceback frames forwarded (keeps payloads focused)
+_MAX_TRACEBACK_FRAMES = 15
+
+# Keys whose *values* will be masked in headers / body payloads.
+# Matching is case-insensitive and checks whether the key *contains* the word.
+_SENSITIVE_PATTERNS: re.Pattern[str] = re.compile(
+    r"(password|secret|token|authorization)", re.IGNORECASE
+)
+
+_MASK = "********"
+
+
+# ---------------------------------------------------------------------------
+# Data scrubbing
+# ---------------------------------------------------------------------------
+
+
+def _is_sensitive_key(key: str) -> bool:
+    """Return ``True`` if *key* looks like it holds a sensitive value."""
+    return bool(_SENSITIVE_PATTERNS.search(key))
+
+
+def _scrub(data: Any) -> Any:
+    """Recursively walk *data* and mask values behind sensitive keys.
+
+    Handles nested dicts and lists.  Everything else passes through
+    unchanged.
+    """
+    if isinstance(data, dict):
+        sanitised: dict[str, Any] = {}
+        for key, value in data.items():
+            if _is_sensitive_key(str(key)):
+                sanitised[key] = _MASK
+            else:
+                sanitised[key] = _scrub(value)
+        return sanitised
+
+    if isinstance(data, (list, tuple)):
+        return [_scrub(item) for item in data]
+
+    return data
+
+
+# ---------------------------------------------------------------------------
+# Request helpers
+# ---------------------------------------------------------------------------
+
+
+def _extract_headers(request: HttpRequest) -> dict[str, str]:
+    """Pull HTTP headers from ``request.META``, scrubbing sensitive ones."""
+    headers: dict[str, str] = {}
+    for meta_key, meta_value in request.META.items():
+        if not meta_key.startswith("HTTP_"):
+            continue
+        # Convert META key (e.g. HTTP_ACCEPT_LANGUAGE) → header name
+        header_name = meta_key[5:].replace("_", "-").title()
+        if _is_sensitive_key(header_name):
+            headers[header_name] = _MASK
+        else:
+            headers[header_name] = str(meta_value)
+    return headers
+
+
+def _extract_body(request: HttpRequest) -> dict[str, Any]:
+    """Best-effort parse + scrub of the request body."""
+    try:
+        raw = request.body
+        if not raw:
+            return {}
+        payload = json.loads(raw.decode("utf-8"))
+    except Exception:
+        # Body might be form-encoded, binary, or otherwise unparsable.
+        # Wrap it as a raw string so we still capture *something*.
+        try:
+            payload = {"_raw": request.body.decode("utf-8", errors="replace")}
+        except Exception:
+            return {}
+
+    return _scrub(payload)
+
+
+def _extract_traceback(exc: BaseException) -> list[str]:
+    """Return a compact, relevant traceback as a list of formatted lines.
+
+    We limit output to ``_MAX_TRACEBACK_FRAMES`` innermost frames so that
+    payloads stay small and focused on application code rather than deep
+    framework internals.
+    """
+    tb_lines = traceback.format_exception(type(exc), exc, exc.__traceback__)
+    # ``format_exception`` returns a list of multi-line strings; flatten.
+    flat: list[str] = []
+    for chunk in tb_lines:
+        flat.extend(chunk.splitlines())
+
+    # Keep only the tail (most relevant frames) + the final exception line.
+    if len(flat) > _MAX_TRACEBACK_FRAMES:
+        flat = ["... (truncated)"] + flat[-_MAX_TRACEBACK_FRAMES:]
+
+    return flat
+
+
+# ---------------------------------------------------------------------------
+# Payload construction
+# ---------------------------------------------------------------------------
+
+
+def _build_payload(
+    request: HttpRequest, exception: BaseException
+) -> dict[str, Any]:
+    """Assemble the JSON-serialisable error payload."""
+    return {
+        "exception": {
+            "type": type(exception).__qualname__,
+            "message": str(exception),
+            "traceback": _extract_traceback(exception),
+        },
+        "request": {
+            "method": request.method,
+            "path": request.path,
+            "query_string": request.META.get("QUERY_STRING", ""),
+            "headers": _extract_headers(request),
+            "body": _extract_body(request),
+        },
+        "server": {
+            "server_name": request.META.get("SERVER_NAME", ""),
+            "server_port": request.META.get("SERVER_PORT", ""),
+        },
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "sdk": {
+            "name": "autotrace-python",
+            "version": "0.1.0",
+        },
+    }
+
+
+# ---------------------------------------------------------------------------
+# Transport
+# ---------------------------------------------------------------------------
+
+
+def _send_payload(payload: dict[str, Any], dsn: str, api_key: str) -> None:
+    """POST *payload* to the AutoTrace ingestion endpoint.
+
+    Uses only the stdlib ``urllib`` so we avoid adding ``requests`` as a
+    hard dependency for SDK consumers.
+
+    This function is wrapped in a blanket ``try / except`` at the call
+    site so that transport failures **never** propagate to the host app.
+    """
+    body = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        dsn,
+        data=body,
+        headers={
+            "Content-Type": "application/json",
+            "X-AutoTrace-Key": api_key,
+        },
+        method="POST",
+    )
+    urllib.request.urlopen(req, timeout=5)
+
+
+# ---------------------------------------------------------------------------
+# Middleware
+# ---------------------------------------------------------------------------
+
+
+class AutoTraceMiddleware:
+    """Django middleware that reports unhandled exceptions to AutoTrace.
+
+    Configuration is read from ``django.conf.settings``:
+
+    ========================  ======================================
+    Setting                   Description
+    ========================  ======================================
+    ``AUTOTRACE_DSN``         Ingestion URL (default: ``https://api.autotrace.io/ingest/``)
+    ``AUTOTRACE_API_KEY``     Project API key (required)
+    ``AUTOTRACE_ENABLED``     Kill-switch — set ``False`` to disable (default: ``True``)
+    ========================  ======================================
+    """
+
+    def __init__(self, get_response: Callable[[HttpRequest], HttpResponse]) -> None:
+        self.get_response = get_response
+
+        # Read configuration once at startup.
+        self.dsn: str = getattr(settings, "AUTOTRACE_DSN", _DEFAULT_DSN)
+        self.api_key: str = getattr(settings, "AUTOTRACE_API_KEY", "")
+        self.enabled: bool = getattr(settings, "AUTOTRACE_ENABLED", True)
+
+        if self.enabled and not self.api_key:
+            logger.warning(
+                "AutoTraceMiddleware is enabled but AUTOTRACE_API_KEY is not "
+                "set.  Error reports will be sent without authentication."
+            )
+
+    # -- Django middleware interface ------------------------------------------
+
+    def __call__(self, request: HttpRequest) -> HttpResponse:
+        """Wrap the downstream middleware / view chain."""
+        try:
+            response = self.get_response(request)
+        except Exception as exc:
+            # Capture → report → re-raise so Django's error handling
+            # (DEBUG page, logging, etc.) still works normally.
+            self._report(request, exc)
+            raise
+
+        return response
+
+    # -- Internal helpers ----------------------------------------------------
+
+    def _report(self, request: HttpRequest, exception: BaseException) -> None:
+        """Build and ship the error payload — silently swallowing any errors
+        that occur during reporting so we never break the host application.
+        """
+        if not self.enabled:
+            return
+
+        try:
+            payload = _build_payload(request, exception)
+            _send_payload(payload, self.dsn, self.api_key)
+            logger.debug("AutoTrace: error reported successfully.")
+        except Exception:
+            # ----- FAIL SILENTLY -----
+            # If AutoTrace's servers are unreachable, misconfigured, or the
+            # payload can't be serialised, we absolutely must not let that
+            # crash the client's application a *second* time.
+            logger.debug(
+                "AutoTrace: failed to report error (suppressed).",
+                exc_info=True,
+            )

autotrace_py-0.1.0/autotrace_py.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: autotrace-py
+Version: 0.1.0
+Summary: AutoTrace Python SDK for autonomous error tracking and AI triage
+Author-email: AutoTrace Team <maintainers@autotrace.io>
+License: MIT
+Project-URL: Homepage, https://autotrace.io
+Project-URL: Repository, https://github.com/autotrace/autotrace-py
+Project-URL: Documentation, https://docs.autotrace.io
+Keywords: error-tracking,ai-triage,gemini,monitoring,exceptions
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: System :: Monitoring
+Classifier: Topic :: Software Development :: Bug Tracking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: django
+Requires-Dist: django>=3.2; extra == "django"
+Provides-Extra: fastapi
+Requires-Dist: starlette>=0.14.0; extra == "fastapi"
+
+# AutoTrace Python SDK (`autotrace-py`)
+
+Lightweight, zero-dependency Python client for autonomous error tracking and AI triage with [AutoTrace](https://autotrace.io).
+
+## Installation
+
+```bash
+pip install autotrace
+# or from source:
+pip install -e ./sdk/python
+```
+
+## Quickstart
+
+```python
+import autotrace
+
+# 1. Initialize once at application startup
+autotrace.init(
+    api_key="<YOUR_API_KEY>",
+    endpoint_url="http://localhost:8000/api/ingest/",
+    environment="production",
+    context={"service": "payment-api", "version": "2.1.0"},
+)
+
+# 2. Manual Exception Capture
+try:
+    process_order()
+except Exception as exc:
+    autotrace.capture_exception(
+        exc_info=exc,
+        endpoint="/api/v1/orders",
+        context={"user_id": "usr_123"},
+    )
+```
+
+## Function Decorator
+
+```python
+@autotrace.trace(endpoint="/jobs/sync-inventory")
+def sync_inventory():
+    # If this raises, AutoTrace captures the error and traceback
+    perform_risky_task()
+```
+
+## Framework Integrations
+
+### Django
+
+In your `settings.py`:
+```python
+AUTOTRACE_API_KEY = "<YOUR_API_KEY>"
+AUTOTRACE_ENDPOINT = "http://localhost:8000/api/ingest/"
+
+MIDDLEWARE = [
+    # ... other middleware
+    "autotrace.integrations.django.AutoTraceMiddleware",
+]
+```
+
+### FastAPI / Starlette
+
+In your `main.py`:
+```python
+from fastapi import FastAPI
+import autotrace
+from autotrace.integrations.fastapi import AutoTraceMiddleware
+
+autotrace.init(api_key="<YOUR_API_KEY>")
+
+app = FastAPI()
+app.add_middleware(AutoTraceMiddleware)
+```

autotrace_py-0.1.0/autotrace_py.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+MANIFEST.in
+README.md
+pyproject.toml
+./autotrace/__init__.py
+./autotrace/client.py
+./autotrace/middleware.py
+./autotrace/integrations/__init__.py
+./autotrace/integrations/django.py
+./autotrace/integrations/fastapi.py
+autotrace/__init__.py
+autotrace/client.py
+autotrace/middleware.py
+autotrace/integrations/__init__.py
+autotrace/integrations/django.py
+autotrace/integrations/fastapi.py
+autotrace_py.egg-info/PKG-INFO
+autotrace_py.egg-info/SOURCES.txt
+autotrace_py.egg-info/dependency_links.txt
+autotrace_py.egg-info/requires.txt
+autotrace_py.egg-info/top_level.txt

autotrace_py-0.1.0/autotrace_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

autotrace_py-0.1.0/autotrace_py.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[django]
+django>=3.2
+
+[fastapi]
+starlette>=0.14.0

autotrace_py-0.1.0/autotrace_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+autotrace

autotrace_py-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "autotrace-py"
+version = "0.1.0"
+description = "AutoTrace Python SDK for autonomous error tracking and AI triage"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "AutoTrace Team", email = "maintainers@autotrace.io"}
+]
+keywords = ["error-tracking", "ai-triage", "gemini", "monitoring", "exceptions"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Monitoring",
+    "Topic :: Software Development :: Bug Tracking",
+]
+dependencies = []
+
+[project.optional-dependencies]
+django = ["django>=3.2"]
+fastapi = ["starlette>=0.14.0"]
+
+[project.urls]
+Homepage = "https://autotrace.io"
+Repository = "https://github.com/autotrace/autotrace-py"
+Documentation = "https://docs.autotrace.io"
+
+[tool.setuptools]
+package-dir = {"" = "."}
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["autotrace*"]
+namespaces = false

autotrace_py-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+