xecurecode-reliability-sdk 0.1.1__py3-none-any.whl

reliability/__init__.py

@@ -0,0 +1,17 @@
+"""
+XecureCode Reliability SDK for Python
+"""
+
+from .config import ReliabilityConfig
+from .client import ReliabilityClient, init, get_client
+from .payload import create_error_payload
+
+__version__ = "0.1.1"
+
+__all__ = [
+    "ReliabilityConfig",
+    "ReliabilityClient",
+    "create_error_payload",
+    "init",
+    "get_client",
+]

reliability/client.py

@@ -0,0 +1,265 @@
+"""
+Reliability Client for Python SDK
+"""
+
+import asyncio
+import json
+import logging
+import sys
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, Optional
+from urllib.request import Request, urlopen
+
+from .config import ReliabilityConfig
+from .payload import create_error_payload
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_ENDPOINT = "https://api.xecurecode.in/api/v1/ingest"
+
+DEDUP_WINDOW_MS = 60000
+MIN_INTERVAL_MS = 100
+MAX_PENDING = 100
+
+
+class ReliabilityClient:
+    """Main reliability client for capturing and sending errors"""
+
+    def __init__(self, config: ReliabilityConfig):
+        self.config = config
+        self._executor = ThreadPoolExecutor(
+            max_workers=1, thread_name_prefix="reliability-sender"
+        )
+        self._shutdown_flag = False
+
+        # Rate limiting
+        self._last_sent_time = 0
+        self._pending_sends = 0
+        self._lock = threading.Lock()
+
+        # Deduplication cache
+        self._error_cache: Dict[str, float] = {}
+        self._error_counts: Dict[str, int] = {}
+        self._cache_cleanup_interval = 60
+        self._cleanup_stop = threading.Event()
+        self._cleanup_thread: Optional[threading.Thread] = None
+        self._start_cache_cleanup()
+
+        # Global exception handlers
+        self._setup_global_handlers()
+
+        logger.info(f"ReliabilityClient initialized for service: {config.service_id}")
+
+    def _setup_global_handlers(self):
+        """Setup global exception handlers"""
+        self._original_excepthook = sys.excepthook
+        self._original_thread_excepthook = threading.excepthook
+
+        sys.excepthook = self._custom_excepthook
+        threading.excepthook = self._custom_thread_excepthook
+
+    def _custom_excepthook(self, exc_type, exc_value, exc_traceback):
+        """Custom uncaught exception handler"""
+        try:
+            if issubclass(exc_type, Exception):
+                self.capture(exc_value)
+        except Exception:
+            pass
+        if self._original_excepthook:
+            self._original_excepthook(exc_type, exc_value, exc_traceback)
+
+    def _custom_thread_excepthook(self, args):
+        """Custom thread exception handler"""
+        try:
+            if args.exc_type and issubclass(args.exc_type, Exception):
+                self.capture(args.exc_value)
+        except Exception:
+            pass
+        if self._original_thread_excepthook:
+            self._original_thread_excepthook(args)
+
+    def _start_cache_cleanup(self):
+        """Start background cache cleanup"""
+
+        def cleanup():
+            while not self._cleanup_stop.wait(self._cache_cleanup_interval):
+                self._cleanup_cache()
+
+        self._cleanup_thread = threading.Thread(
+            target=cleanup,
+            name="reliability-cache-cleanup",
+            daemon=True,
+        )
+        self._cleanup_thread.start()
+
+    def _cleanup_cache(self):
+        """Remove old entries from cache"""
+        now = time.time() * 1000
+        expired_keys = [
+            k for k, v in self._error_cache.items() if now - v > DEDUP_WINDOW_MS
+        ]
+        for k in expired_keys:
+            self._error_cache.pop(k, None)
+            self._error_counts.pop(k, None)
+
+    def _record_fingerprint(self, fingerprint: str) -> int:
+        """Record a fingerprint occurrence and return the accumulated count."""
+        now = time.time() * 1000
+        last_time = self._error_cache.get(fingerprint)
+        current_count = self._error_counts.get(fingerprint, 0)
+
+        if last_time is None:
+            self._error_cache[fingerprint] = now
+            self._error_counts[fingerprint] = 1
+            return 1
+
+        if now - last_time > DEDUP_WINDOW_MS:
+            self._error_cache[fingerprint] = now
+            self._error_counts[fingerprint] = 1
+            return 1
+
+        self._error_cache[fingerprint] = now
+        current_count += 1
+        self._error_counts[fingerprint] = current_count
+        return current_count
+
+    def _can_send(self) -> bool:
+        """Check if we can send (rate limiting)"""
+        now = time.time() * 1000
+        with self._lock:
+            if now - self._last_sent_time < MIN_INTERVAL_MS:
+                return False
+            if self._pending_sends >= MAX_PENDING:
+                return False
+            return True
+
+    def capture(self, error: Exception, request: Any = None):
+        """Capture an error - never throws"""
+        try:
+            if error is None:
+                return
+            if self._shutdown_flag:
+                logger.debug("Client shut down, dropping event")
+                return
+
+            payload = create_error_payload(
+                error,
+                self.config.service_id,
+                self.config.mode,
+                request,
+                version=self.config.version,
+                release=self.config.release,
+                commit_hash=self.config.commit_hash,
+                branch=self.config.branch,
+                build_id=self.config.build_id,
+                deployment_id=self.config.deployment_id,
+            )
+
+            occurrence_count = self._record_fingerprint(payload["fingerprint"])
+
+            if not self._can_send():
+                logger.debug(f"Rate limited, skipping: {error}")
+                return
+
+            with self._lock:
+                self._pending_sends += 1
+                self._last_sent_time = time.time() * 1000
+
+            payload["occurrenceCount"] = occurrence_count
+
+            try:
+                self._executor.submit(self._send_to_backend, payload)
+            except RuntimeError:
+                with self._lock:
+                    self._pending_sends -= 1
+                logger.debug("Executor unavailable, dropping event")
+        except Exception as e:
+            logger.exception(f"Reliability SDK internal error in capture(): {e}")
+
+    def _send_to_backend(self, payload: Dict[str, Any]):
+        """Send payload to backend with retry"""
+        max_retries = 3
+        retry_delay = 1
+        try:
+            for attempt in range(max_retries):
+                try:
+                    self._do_send(payload)
+                    logger.debug(f"Error sent successfully: {payload['message']}")
+                    break
+                except Exception as e:
+                    logger.warning(f"Failed to send error (attempt {attempt + 1}): {e}")
+                    if attempt < max_retries - 1:
+                        time.sleep(retry_delay * (attempt + 1))
+        finally:
+            with self._lock:
+                self._pending_sends -= 1
+
+    def _do_send(self, payload: Dict[str, Any]):
+        """Perform actual HTTP request"""
+        data = json.dumps(payload).encode("utf-8")
+        endpoint = self.config.endpoint or DEFAULT_ENDPOINT
+
+        request = Request(
+            endpoint,
+            data=data,
+            headers={
+                "Content-Type": "application/json",
+                "xc-api-key": self.config.api_key,
+                "xc-service-id": self.config.service_id,
+            },
+            method="POST",
+        )
+
+        with urlopen(request, timeout=self.config.timeout / 1000) as response:
+            if response.status >= 400:
+                raise Exception(f"HTTP {response.status}")
+
+    def middleware(self):
+        """Create middleware for frameworks"""
+        return ReliabilityMiddleware(self)
+
+    async def flush(self):
+        """Flush pending sends"""
+        while self._pending_sends > 0:
+            await asyncio.sleep(0.1)
+
+    def shutdown(self):
+        """Shutdown the client"""
+        self._shutdown_flag = True
+        if getattr(self, "_original_excepthook", None):
+            sys.excepthook = self._original_excepthook
+        if getattr(self, "_original_thread_excepthook", None):
+            threading.excepthook = self._original_thread_excepthook
+        self._cleanup_stop.set()
+        self._executor.shutdown(wait=True)
+
+
+class ReliabilityMiddleware:
+    """Middleware for FastAPI/Flask"""
+
+    def __init__(self, client: ReliabilityClient):
+        self.client = client
+
+    async def __call__(self, request, call_next):
+        """Process request"""
+        try:
+            response = await call_next(request)
+            return response
+        except Exception as e:
+            self.client.capture(e, request)
+            raise
+
+
+def get_client() -> ReliabilityClient:
+    """Get global client instance"""
+    if not hasattr(get_client, "_instance"):
+        raise RuntimeError("ReliabilityClient not initialized. Call init() first.")
+    return get_client._instance
+
+
+def init(config: ReliabilityConfig) -> ReliabilityClient:
+    """Initialize global client"""
+    get_client._instance = ReliabilityClient(config)
+    return get_client._instance

reliability/config.py

@@ -0,0 +1,33 @@
+"""
+Reliability Config for Python SDK
+"""
+
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+Mode = Literal["development", "production"]
+
+
+@dataclass
+class ReliabilityConfig:
+    api_key: str
+    service_id: str
+    mode: Mode = "development"
+    timeout: int = 5000
+    endpoint: Optional[str] = None
+    version: Optional[str] = None
+    release: Optional[str] = None
+    commit_hash: Optional[str] = None
+    branch: Optional[str] = None
+    build_id: Optional[str] = None
+    deployment_id: Optional[str] = None
+
+    def __post_init__(self):
+        if not self.api_key:
+            raise ValueError("API Key is required")
+        if not self.service_id:
+            raise ValueError("Service ID is required")
+        if self.mode not in ["development", "production"]:
+            raise ValueError("Mode must be 'development' or 'production'")
+        if self.timeout <= 0:
+            raise ValueError("Timeout must be greater than 0")

reliability/django_integration.py

@@ -0,0 +1,66 @@
+"""
+Django Integration
+"""
+
+import logging
+import sys
+from typing import Optional
+
+from django.utils.deprecation import MiddlewareMixin
+
+from .client import ReliabilityClient
+from .config import ReliabilityConfig
+
+logger = logging.getLogger(__name__)
+
+_client: Optional[ReliabilityClient] = None
+
+
+def get_client() -> Optional[ReliabilityClient]:
+    """Get or create Django client"""
+    global _client
+    if _client is None:
+        from django.conf import settings
+
+        api_key = getattr(settings, "RELIABILITY_API_KEY", None)
+        service_id = getattr(settings, "RELIABILITY_SERVICE_ID", None)
+        mode = getattr(settings, "RELIABILITY_MODE", "development")
+
+        if not api_key or not service_id:
+            logger.warning(
+                "Reliability SDK not configured. Add API_KEY and SERVICE_ID to settings."
+            )
+            return None
+
+        config = ReliabilityConfig(api_key=api_key, service_id=service_id, mode=mode)
+        _client = ReliabilityClient(config)
+
+    return _client
+
+
+class ReliabilityMiddleware(MiddlewareMixin):
+    """Django middleware for error capture"""
+
+    def process_exception(self, request, exception):
+        """Capture exceptions"""
+        client = get_client()
+        if client:
+            client.capture(exception, request)
+        return None
+
+
+# Django signals for automatic capture
+def setup_django_signals():
+    """Setup Django signals for automatic error capture"""
+    try:
+        from django.core.signals import got_request_exception
+        from django.dispatch import receiver
+
+        @receiver(got_request_exception)
+        def capture_exception(sender, request=None, **kwargs):
+            client = get_client()
+            exception = sys.exc_info()[1]
+            if client and exception:
+                client.capture(exception, request)
+    except ImportError:
+        pass

reliability/fastapi_integration.py

@@ -0,0 +1,38 @@
+"""
+FastAPI Integration
+"""
+
+from fastapi import FastAPI, Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+from typing import Callable, Type
+
+from .client import ReliabilityClient
+
+
+class FastAPIMiddleware(BaseHTTPMiddleware):
+    """FastAPI middleware for error capture"""
+
+    def __init__(self, app: FastAPI, client: ReliabilityClient):
+        super().__init__(app)
+        self.client = client
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        try:
+            response = await call_next(request)
+            return response
+        except Exception as e:
+            self.client.capture(e, request)
+            raise
+
+
+def setup_fastapi(app: FastAPI, client: ReliabilityClient):
+    """Setup FastAPI integration"""
+    app.add_middleware(FastAPIMiddleware, client=client)
+
+
+def create_fastapi_middleware(client: ReliabilityClient) -> Type[FastAPIMiddleware]:
+    """Create a configured FastAPI middleware class for manual use with add_middleware"""
+    class _Configured(FastAPIMiddleware):
+        def __init__(self, app: FastAPI):
+            super().__init__(app, client)
+    return _Configured

reliability/flask_integration.py

@@ -0,0 +1,56 @@
+"""
+Flask Integration
+"""
+
+from flask import Flask, Response
+from typing import Callable
+
+from .client import ReliabilityClient
+
+
+class FlaskMiddleware:
+    """Flask middleware for error capture"""
+
+    def __init__(self, app: Callable, client: ReliabilityClient):
+        self.app = app
+        self.client = client
+
+    def __call__(self, environ: dict, start_response: Callable) -> Response:
+        # Wrap start_response to capture exceptions
+        def wrapped_start_response(status, headers, exc_info=None):
+            return start_response(status, headers, exc_info)
+
+        try:
+            # Use Flask's internal mechanism
+            from flask import g
+
+            return self.app(environ, wrapped_start_response)
+        except Exception as e:
+            # Get request object from Flask
+            from flask import request
+
+            self.client.capture(e, request)
+            raise
+
+
+def init_flask(app: Flask, client: ReliabilityClient):
+    """Initialize Flask integration"""
+
+    @app.errorhandler(Exception)
+    def handle_error(error):
+        from flask import request
+
+        client.capture(error, request)
+        return {"error": "Internal server error"}, 500
+
+
+def create_flask_error_handler(client: ReliabilityClient):
+    """Create Flask error handler for manual use"""
+
+    def handle_error(error):
+        from flask import request
+
+        client.capture(error, request)
+        return {"error": "Internal server error"}, 500
+
+    return handle_error

reliability/payload.py

@@ -0,0 +1,239 @@
+"""
+Error Payload for Python SDK
+"""
+
+import hashlib
+import platform
+import os
+import re
+import traceback
+from types import TracebackType
+from typing import Any, Dict, Optional, TypedDict, Union
+from datetime import datetime
+
+
+class ServiceContext(TypedDict, total=False):
+    pid: int
+    runtime: str
+    runtimeVersion: str
+    pythonVersion: str
+    platform: str
+    hostname: str
+
+
+class RequestContext(TypedDict, total=False):
+    method: str
+    url: str
+    ip: str
+    userAgent: str
+    headers: Dict[str, Any]
+    body: Any
+    query: Any
+    cookies: Any
+
+
+class ErrorPayload(TypedDict, total=False):
+    message: str
+    name: str
+    stack: str
+    fingerprint: str
+    timestamp: int
+    service: str
+    environment: str
+    version: str
+    release: str
+    commitHash: str
+    branch: str
+    buildId: str
+    deploymentId: str
+    occurrenceCount: int
+    severity: str
+    errorType: str
+    serviceContext: ServiceContext
+    requestContext: RequestContext
+
+
+def _generate_fingerprint(error: Exception, stack: Optional[str] = None) -> str:
+    signature = str(error)
+    if stack:
+        first_line = stack.split("\n")[0] if stack else ""
+        signature += first_line
+    return hashlib.sha256(signature.encode()).hexdigest()
+
+
+_SENSITIVE_KEYS = {
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key",
+    "api-key",
+    "apikey",
+    "password",
+    "token",
+    "access_token",
+    "refresh_token",
+    "secret",
+    "signature",
+}
+
+
+def _sanitize_text(value: str) -> str:
+    value = re.sub(r"Bearer\s+\S+", "Bearer [REDACTED]", value)
+    for keyword in ("token", "password", "secret", "api_key", "apikey"):
+        value = re.sub(rf"{re.escape(keyword)}=\S*", f"{keyword}=[REDACTED]", value)
+    return value
+
+
+def _sanitize_value(value: Any) -> Any:
+    if isinstance(value, str):
+        return _sanitize_text(value)
+    if isinstance(value, dict):
+        return {
+            key: "[REDACTED]" if key.lower() in _SENSITIVE_KEYS else _sanitize_value(item)
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [_sanitize_value(item) for item in value]
+    return value
+
+
+def _classify_error(error: Exception) -> str:
+    msg = str(error).lower()
+    if any(
+        keyword in msg
+        for keyword in ["database", "sql", "psycopg", "mysql", "sqlite"]
+    ):
+        return "DATABASE"
+    if any(
+        keyword in msg
+        for keyword in ["network", "http", "socket", "connection", "timeout", "ssl"]
+    ):
+        return "NETWORK"
+    if any(
+        keyword in msg
+        for keyword in ["validation", "invalid", "required", "constraint", "type"]
+    ):
+        return "VALIDATION"
+    if any(
+        keyword in msg
+        for keyword in ["permission", "denied", "forbidden", "unauthorized"]
+    ):
+        return "AUTH"
+    return "RUNTIME"
+
+
+def _determine_severity(error: Exception) -> str:
+    msg = str(error).lower()
+    if any(
+        keyword in msg
+        for keyword in ["database", "connection", "timeout", "fatal", "crash"]
+    ):
+        return "critical"
+    return "medium"
+
+
+def _format_stack_trace(stack: Optional[Union[str, TracebackType]] = None) -> Optional[str]:
+    if not stack:
+        return None
+    if isinstance(stack, str):
+        return stack
+    try:
+        return "".join(traceback.format_tb(stack))
+    except Exception:
+        return None
+
+
+def _build_service_context() -> ServiceContext:
+    return {
+        "pid": os.getpid(),
+        "runtime": "python",
+        "runtimeVersion": platform.python_version(),
+        "pythonVersion": platform.python_version(),
+        "platform": platform.platform(),
+        "hostname": platform.node() or os.environ.get("HOSTNAME", "unknown"),
+    }
+
+
+def _extract_request_context(request: Optional[Any] = None) -> Optional[RequestContext]:
+    if request is None:
+        return None
+    context: RequestContext = {}
+
+    if hasattr(request, "method"):
+        context["method"] = request.method
+    if hasattr(request, "url"):
+        context["url"] = str(request.url)
+    if hasattr(request, "client") and request.client:
+        context["ip"] = request.client.host
+    if hasattr(request, "remote_addr"):
+        context["ip"] = request.remote_addr
+    if hasattr(request, "path"):
+        context["url"] = context.get("url", request.path)
+    if hasattr(request, "META"):
+        context["ip"] = request.META.get("REMOTE_ADDR")
+        context["method"] = request.method
+        context["url"] = request.path
+    if hasattr(request, "headers"):
+        headers = dict(request.headers)
+        forwarded = headers.get("x-forwarded-for")
+        if forwarded and not context.get("ip"):
+            context["ip"] = forwarded.split(",")[0].strip()
+        user_agent = headers.get("user-agent")
+        if user_agent:
+            context["userAgent"] = user_agent
+        context["headers"] = _sanitize_value(headers)
+
+    body = request.json if hasattr(request, "json") and not callable(request.json) else None
+    if body is not None:
+        context["body"] = _sanitize_value(body)
+    elif hasattr(request, "body") and request.body is not None:
+        context["body"] = _sanitize_value(request.body)
+
+    if hasattr(request, "args") and request.args is not None:
+        context["query"] = _sanitize_value(dict(request.args))
+    if hasattr(request, "cookies") and request.cookies is not None:
+        context["cookies"] = _sanitize_value(dict(request.cookies))
+    return context if context else None
+
+
+def create_error_payload(
+    error: Exception,
+    service_id: str,
+    mode: str,
+    request: Optional[Any] = None,
+    *,
+    version: Optional[str] = None,
+    release: Optional[str] = None,
+    commit_hash: Optional[str] = None,
+    branch: Optional[str] = None,
+    build_id: Optional[str] = None,
+    deployment_id: Optional[str] = None,
+) -> ErrorPayload:
+    stack = getattr(error, "__fake_tb__", None) or _format_stack_trace(
+        error.__traceback__
+    )
+    fingerprint = _generate_fingerprint(error, stack)
+    return {
+        "message": str(error),
+        "name": type(error).__name__,
+        "stack": stack or "",
+        "fingerprint": fingerprint,
+        "timestamp": int(datetime.now().timestamp() * 1000),
+        "service": service_id,
+        "environment": mode,
+        **({"version": version} if version else {}),
+        **({"release": release} if release else {}),
+        **({"commitHash": commit_hash} if commit_hash else {}),
+        **({"branch": branch} if branch else {}),
+        **({"buildId": build_id} if build_id else {}),
+        **({"deploymentId": deployment_id} if deployment_id else {}),
+        "occurrenceCount": 1,
+        "severity": _determine_severity(error),
+        "errorType": _classify_error(error),
+        "serviceContext": _build_service_context(),
+        **(
+            {"requestContext": request_context}
+            if (request_context := _extract_request_context(request)) is not None
+            else {}
+        ),
+    }

xecurecode_reliability_sdk-0.1.1.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: xecurecode-reliability-sdk
+Version: 0.1.1
+Summary: AI-driven reliability SDK for Python applications
+Author-email: XecureCode Team <team@xecurecode.in>
+License: MIT
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100; extra == "fastapi"
+Provides-Extra: flask
+Requires-Dist: flask>=2.0; extra == "flask"
+Provides-Extra: django
+Requires-Dist: django>=3.0; extra == "django"
+Dynamic: license-file
+
+# XecureCode Reliability SDK - Python
+
+AI-driven reliability SDK for Python applications.
+
+The official Python SDK for the XecureCode Reliability Platform — a human-first failure analysis and recovery recommendation system.
+
+---
+
+## Why This SDK Exists
+
+Modern backend systems fail in unpredictable ways.
+
+This SDK:
+
+- Captures structured runtime errors
+- Generates deterministic fingerprints
+- Classifies error types (DATABASE, NETWORK, VALIDATION, etc.)
+- Determines severity
+- Sends non-blocking telemetry to your backend
+- Never crashes your application
+
+**AI assists. Humans decide. Nothing executes automatically.**
+
+---
+
+## Requirements
+
+- Python 3.8+
+- FastAPI, Flask, or Django (optional)
+
+---
+
+## Installation
+
+```bash
+pip install xecurecode-reliability-sdk
+```
+
+Or install with framework support:
+
+```bash
+pip install xecurecode-reliability-sdk[fastapi,flask,django]
+```
+
+---
+
+## Quick Start
+
+### 1️⃣ Initialize the SDK
+
+```python
+from reliability import ReliabilityClient, ReliabilityConfig
+
+config = ReliabilityConfig(
+    api_key="your-api-key",
+    service_id="your-service",
+    mode="development"
+)
+client = ReliabilityClient(config)
+```
+
+**Configuration Options:**
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `api_key` | Yes | Your API key |
+| `service_id` | Yes | Service identifier |
+| `mode` | Yes | `development` or `production` |
+| `timeout` | No | Request timeout (default: 5000ms) |
+
+---
+
+### 2️⃣ Automatic Global Error Capture
+
+The SDK automatically handles:
+- Uncaught exceptions
+- Thread exceptions
+
+```python
+# This will be automatically captured
+raise ValueError("Database timeout")
+```
+
+---
+
+### 3️⃣ FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from reliability import ReliabilityClient, ReliabilityConfig
+from reliability.fastapi_integration import FastAPIMiddleware
+
+config = ReliabilityConfig(...)
+client = ReliabilityClient(config)
+
+app = FastAPI()
+app.add_middleware(FastAPIMiddleware, client=client)
+```
+
+---
+
+### 4️⃣ Flask Integration
+
+```python
+from flask import Flask
+from reliability import ReliabilityClient, ReliabilityConfig
+from reliability.flask_integration import init_flask
+
+config = ReliabilityConfig(...)
+client = ReliabilityClient(config)
+
+app = Flask(__name__)
+init_flask(app, client)
+```
+
+---
+
+### 5️⃣ Django Integration
+
+In `settings.py`:
+
+```python
+RELIABILITY_API_KEY = "your-api-key"
+RELIABILITY_SERVICE_ID = "your-service"
+RELIABILITY_MODE = "development"
+```
+
+In `settings.py` MIDDLEWARE:
+
+```python
+MIDDLEWARE = [
+    ...
+    'reliability.django_integration.ReliabilityMiddleware',
+    ...
+]
+```
+
+---
+
+### 6️⃣ Manual Capture
+
+```python
+try:
+    risky_operation()
+except Exception as e:
+    client.capture(e)
+
+# With request context
+client.capture(e, request)
+```
+
+---
+
+## What Gets Sent
+
+Example structured payload:
+
+```json
+{
+  "message": "Database connection failed",
+  "name": "ValueError",
+  "fingerprint": "a8c39c21...",
+  "timestamp": 1700000000000,
+  "service": "my-service",
+  "environment": "development",
+  "severity": "critical",
+  "errorType": "DATABASE",
+  "serviceContext": {
+    "pid": 12345,
+    "runtime": "python",
+    "runtimeVersion": "3.11.0",
+    "pythonVersion": "3.11.0",
+    "platform": "Linux-5.10.0",
+    "hostname": "server-01"
+  },
+  "requestContext": {
+    "method": "GET",
+    "url": "/api/users",
+    "ip": "10.0.0.5"
+  },
+  "occurrenceCount": 1
+}
+```
+
+---
+
+## Error Classification
+
+| Type | Example |
+|------|---------|
+| DATABASE | Timeout, SQL errors, connection issues |
+| NETWORK | HTTP failures, socket errors |
+| VALIDATION | Invalid input, type errors |
+| AUTH | Permission denied |
+| RUNTIME | Standard Python errors |
+
+---
+
+## Severity Detection
+
+- **Critical** → Database, timeout, connection errors
+- **Medium** → Validation, recoverable issues
+
+---
+
+## Design Guarantees
+
+- Non-blocking HTTP calls
+- Timeout protected (5s default)
+- Retry logic (3 attempts)
+- Deduplication (1-minute window)
+- Rate limiting (max 100 concurrent)
+- Never throws inside SDK
+- Never crashes host application
+- Works with FastAPI, Flask, Django
+
+---
+
+## License
+
+MIT

xecurecode_reliability_sdk-0.1.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+reliability/__init__.py,sha256=Cw_L9TJjEXCp6AM0Fbp8oLlfTsU5TOz2o3VJ0pufeyI,329
+reliability/client.py,sha256=IYTvdGLcfPi6t0OlOKmCbrQBFDNCRnShTfywpORvXzE,8805
+reliability/config.py,sha256=SBclrncIc7ntVdrTnXHEU3DJ8HZVyDjhtkjiPa8AuxQ,963
+reliability/django_integration.py,sha256=6iw8sc0FybV1DyJwBLxN08L2eOtLZYMiXm_KusluBFE,1871
+reliability/fastapi_integration.py,sha256=nx6znZGQK_oIu7pYWF-nRcFzoyhNFn9AQ1pgRI18KBs,1170
+reliability/flask_integration.py,sha256=9WigBhUJJl0ATbNc_KAdEBniaHRhpGPsWBrUDKTbrPU,1490
+reliability/payload.py,sha256=oVBkT8CtxLL1JhMU9_gKja7vt3i3y-g8aTz3bDgxAGQ,6988
+reliability/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xecurecode_reliability_sdk-0.1.1.dist-info/licenses/LICENSE,sha256=n61q08jxPdC1UKnkZMidrcD_iAksOya6fWZzXWg5ydE,1068
+xecurecode_reliability_sdk-0.1.1.dist-info/METADATA,sha256=j2JLuKBezwjP-UqZEwBRllubMme0ZrbY14tLDTikh0g,5081
+xecurecode_reliability_sdk-0.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+xecurecode_reliability_sdk-0.1.1.dist-info/top_level.txt,sha256=fVLL6FAOvV9ryG189ku0Ed6AhXksyefSi9HvqgmBBHo,12
+xecurecode_reliability_sdk-0.1.1.dist-info/RECORD,,

xecurecode_reliability_sdk-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xecurecode_reliability_sdk-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 XecureTrace
+
+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.

xecurecode_reliability_sdk-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+reliability