bidar 0.1.0__tar.gz

bidar-0.1.0/LICENSE

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

bidar-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: bidar
+Version: 0.1.0
+Summary: Background error reporting SDK for Python and Django
+Author-email: CyberHuginn <contact@cyberhuginn.com>
+Maintainer-email: CyberHuginn <contact@cyberhuginn.com>
+License: MIT
+Project-URL: Homepage, https://cyberhuginn.com
+Project-URL: Organization, https://fardadnoavar.ir
+Keywords: bidar,error-reporting,django,monitoring,sentry
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: django
+Requires-Dist: Django>=3.2; extra == "django"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-mock>=3; extra == "dev"
+Dynamic: license-file
+
+# bidar-sdk-python
+
+A lightweight error and event reporting SDK for Python applications, with optional Django integration. Reports are submitted in the background so application request handling does not wait for the remote API.
+
+**Author:** CyberHuginn  
+**Organization:** Fardad Noavar  
+**Website:** [cyberhuginn.com](https://cyberhuginn.com)  
+**Organization website:** [fardadnoavar.ir](https://fardadnoavar.ir)  
+**Contact:** contact@cyberhuginn.com
+
+## Installation
+
+```bash
+pip install bidar-sdk-python
+```
+
+For Django projects:
+
+```bash
+pip install "bidar-sdk-python[django]"
+```
+
+## Quick start
+
+```python
+import bidar
+
+bidar.init(
+    url="https://api.bidarhq.ir/api/v1/errors/",
+    access_key="YOUR_ACCESS_KEY",
+    project_name="billing-api",
+    environment="Production",
+    log_level="error",
+    timeout=3.0,
+)
+
+try:
+    run_job()
+except Exception as exc:
+    bidar.capture_exception(exc)
+```
+
+Reports are queued on a background worker. `capture_exception`, `capture_message`, and `capture_event` return immediately with a boolean indicating whether the event was accepted for processing.
+
+## Django integration
+
+Add the middleware to `settings.py`:
+
+```python
+MIDDLEWARE = [
+    # ...
+    "bidar.middleware.BidarMiddleware",
+]
+```
+
+Configure the SDK:
+
+```python
+BIDAR_SDK = {
+    "URL": "https://api.bidarhq.ir/api/v1/errors/",
+    "ACCESS_KEY": "YOUR_ACCESS_KEY",
+    "PROJECT_NAME": "my-django-app",
+    "ENVIRONMENT": "Production",
+    "LOG_LEVEL": "error",
+    "TIMEOUT": 3.0,
+    "ENABLED": True,
+    "MIDDLEWARE_ENABLED": True,
+    "CAPTURE_REQUEST_BODY": False,
+    "DEDUPLICATION_WINDOW": 30,
+    "MAX_WORKERS": 2,
+}
+```
+
+The middleware reports unhandled exceptions and re-raises the original exception. Set `MIDDLEWARE_ENABLED` to `False` to disable automatic middleware reporting without removing the middleware from `MIDDLEWARE`.
+
+The SDK is initialized lazily from `BIDAR_SDK` when the middleware first runs. You can also call `bidar_sdk.init(...)` explicitly during application startup.
+
+## Manual reporting
+
+```python
+import bidar
+
+bidar.capture_exception(error)
+
+bidar.capture_message(
+    "Payment provider is unavailable",
+    level="warning",
+)
+
+bidar.capture_event(
+    {"event": "subscription.renewal_failed", "customer_id": 42},
+    level="error",
+)
+```
+
+## Configuration
+
+| Option | Default | Description |
+|---|---:|---|
+| `url` | Required | HTTP endpoint that receives JSON POST reports |
+| `access_key` | Required | API key sent in `X-Bidar-Access-Key` |
+| `log_level` | `error` | One of `info`, `warning`, or `error` |
+| `project_name` | `None` | Project identifier attached to every event |
+| `environment` | `Production` | Deployment environment |
+| `timeout` | `3.0` | Outbound HTTP timeout in seconds |
+| `enabled` | `True` | Enables or disables all reporting |
+| `middleware_enabled` | `True` | Enables or disables Django middleware reporting |
+| `capture_request_body` | `False` | Opt-in request body capture |
+| `deduplication_window` | `30` | Suppresses identical events within this many seconds; set to `0` to disable |
+| `max_workers` | `2` | Number of background HTTP workers |
+
+Log levels are threshold-based: `info` accepts all levels, `warning` accepts warnings and errors, and `error` accepts errors only.
+
+## Reliability and privacy
+
+- Network requests run in a background thread pool.
+- HTTP failures, serialization errors, and worker failures are contained and do not propagate into application code.
+- `flush()` waits for submitted reports; `shutdown()` flushes and closes the client.
+- Duplicate reports with the same event fingerprint are suppressed during the configured deduplication window.
+- Authorization, cookies, passwords, tokens, secrets, and API-key-like fields are redacted.
+- Request bodies are not captured by default. Enable `CAPTURE_REQUEST_BODY` only after reviewing the data your application sends.
+- The SDK does not intentionally collect local variables or environment variables.
+
+## Lifecycle
+
+```python
+bidar_sdk.flush()
+bidar_sdk.shutdown()
+```
+
+Call `flush()` during controlled shutdown if pending reports should be given a chance to finish. `shutdown()` prevents further submissions until the SDK is initialized again.
+
+## License
+
+MIT

bidar-0.1.0/README.md

@@ -0,0 +1,135 @@
+# bidar-sdk-python
+
+A lightweight error and event reporting SDK for Python applications, with optional Django integration. Reports are submitted in the background so application request handling does not wait for the remote API.
+
+**Author:** CyberHuginn  
+**Organization:** Fardad Noavar  
+**Website:** [cyberhuginn.com](https://cyberhuginn.com)  
+**Organization website:** [fardadnoavar.ir](https://fardadnoavar.ir)  
+**Contact:** contact@cyberhuginn.com
+
+## Installation
+
+```bash
+pip install bidar-sdk-python
+```
+
+For Django projects:
+
+```bash
+pip install "bidar-sdk-python[django]"
+```
+
+## Quick start
+
+```python
+import bidar
+
+bidar.init(
+    url="https://api.bidarhq.ir/api/v1/errors/",
+    access_key="YOUR_ACCESS_KEY",
+    project_name="billing-api",
+    environment="Production",
+    log_level="error",
+    timeout=3.0,
+)
+
+try:
+    run_job()
+except Exception as exc:
+    bidar.capture_exception(exc)
+```
+
+Reports are queued on a background worker. `capture_exception`, `capture_message`, and `capture_event` return immediately with a boolean indicating whether the event was accepted for processing.
+
+## Django integration
+
+Add the middleware to `settings.py`:
+
+```python
+MIDDLEWARE = [
+    # ...
+    "bidar.middleware.BidarMiddleware",
+]
+```
+
+Configure the SDK:
+
+```python
+BIDAR_SDK = {
+    "URL": "https://api.bidarhq.ir/api/v1/errors/",
+    "ACCESS_KEY": "YOUR_ACCESS_KEY",
+    "PROJECT_NAME": "my-django-app",
+    "ENVIRONMENT": "Production",
+    "LOG_LEVEL": "error",
+    "TIMEOUT": 3.0,
+    "ENABLED": True,
+    "MIDDLEWARE_ENABLED": True,
+    "CAPTURE_REQUEST_BODY": False,
+    "DEDUPLICATION_WINDOW": 30,
+    "MAX_WORKERS": 2,
+}
+```
+
+The middleware reports unhandled exceptions and re-raises the original exception. Set `MIDDLEWARE_ENABLED` to `False` to disable automatic middleware reporting without removing the middleware from `MIDDLEWARE`.
+
+The SDK is initialized lazily from `BIDAR_SDK` when the middleware first runs. You can also call `bidar_sdk.init(...)` explicitly during application startup.
+
+## Manual reporting
+
+```python
+import bidar
+
+bidar.capture_exception(error)
+
+bidar.capture_message(
+    "Payment provider is unavailable",
+    level="warning",
+)
+
+bidar.capture_event(
+    {"event": "subscription.renewal_failed", "customer_id": 42},
+    level="error",
+)
+```
+
+## Configuration
+
+| Option | Default | Description |
+|---|---:|---|
+| `url` | Required | HTTP endpoint that receives JSON POST reports |
+| `access_key` | Required | API key sent in `X-Bidar-Access-Key` |
+| `log_level` | `error` | One of `info`, `warning`, or `error` |
+| `project_name` | `None` | Project identifier attached to every event |
+| `environment` | `Production` | Deployment environment |
+| `timeout` | `3.0` | Outbound HTTP timeout in seconds |
+| `enabled` | `True` | Enables or disables all reporting |
+| `middleware_enabled` | `True` | Enables or disables Django middleware reporting |
+| `capture_request_body` | `False` | Opt-in request body capture |
+| `deduplication_window` | `30` | Suppresses identical events within this many seconds; set to `0` to disable |
+| `max_workers` | `2` | Number of background HTTP workers |
+
+Log levels are threshold-based: `info` accepts all levels, `warning` accepts warnings and errors, and `error` accepts errors only.
+
+## Reliability and privacy
+
+- Network requests run in a background thread pool.
+- HTTP failures, serialization errors, and worker failures are contained and do not propagate into application code.
+- `flush()` waits for submitted reports; `shutdown()` flushes and closes the client.
+- Duplicate reports with the same event fingerprint are suppressed during the configured deduplication window.
+- Authorization, cookies, passwords, tokens, secrets, and API-key-like fields are redacted.
+- Request bodies are not captured by default. Enable `CAPTURE_REQUEST_BODY` only after reviewing the data your application sends.
+- The SDK does not intentionally collect local variables or environment variables.
+
+## Lifecycle
+
+```python
+bidar_sdk.flush()
+bidar_sdk.shutdown()
+```
+
+Call `flush()` during controlled shutdown if pending reports should be given a chance to finish. `shutdown()` prevents further submissions until the SDK is initialized again.
+
+## License
+
+MIT

bidar-0.1.0/bidar/__init__.py

@@ -0,0 +1,23 @@
+from .client import (
+    BidarClient,
+    capture_event,
+    capture_exception,
+    capture_message,
+    flush,
+    get_client,
+    init,
+    shutdown,
+)
+
+__all__ = [
+    "BidarClient",
+    "init",
+    "get_client",
+    "capture_exception",
+    "capture_message",
+    "capture_event",
+    "flush",
+    "shutdown",
+]
+
+__version__ = "0.2.0"

bidar-0.1.0/bidar/client.py

@@ -0,0 +1,241 @@
+import hashlib
+import json
+import logging
+import platform
+import sys
+import threading
+import traceback
+from concurrent.futures import ThreadPoolExecutor, wait
+from datetime import datetime, timezone
+from time import monotonic
+
+from .config import Config
+from .transport import Transport
+from .utils.sanitizers import redact_mapping
+
+logger = logging.getLogger("bidar")
+_LEVELS = {"info": 10, "warning": 20, "error": 30}
+_client = None
+_client_lock = threading.RLock()
+
+
+class BidarClient:
+    def __init__(self, config):
+        self.config = config
+        self.transport = Transport(config)
+        self.executor = ThreadPoolExecutor(
+            max_workers=config.max_workers,
+            thread_name_prefix="bidar-sdk",
+        )
+        self._futures = set()
+        self._lock = threading.RLock()
+        self._recent_events = {}
+        self._closed = False
+
+    def _enabled(self, level):
+        level = level.lower()
+        if level not in _LEVELS:
+            raise ValueError("level must be info, warning, or error")
+        return self.config.enabled and _LEVELS[level] >= _LEVELS[self.config.log_level]
+
+    def _fingerprint(self, payload, level):
+        stable = json.dumps(
+            {"level": level, "payload": payload},
+            sort_keys=True,
+            default=str,
+            separators=(",", ":"),
+        )
+        return hashlib.sha256(stable.encode("utf-8")).hexdigest()
+
+    def _is_duplicate(self, fingerprint):
+        window = self.config.deduplication_window
+        if window <= 0:
+            return False
+        now = monotonic()
+        with self._lock:
+            expired = [
+                key for key, timestamp in self._recent_events.items()
+                if now - timestamp >= window
+            ]
+            for key in expired:
+                self._recent_events.pop(key, None)
+            previous = self._recent_events.get(fingerprint)
+            if previous is not None and now - previous < window:
+                return True
+            self._recent_events[fingerprint] = now
+            return False
+
+    def _submit(self, payload):
+        try:
+            if self._closed:
+                return False
+            future = self.executor.submit(self.transport.send, payload)
+            with self._lock:
+                self._futures.add(future)
+            future.add_done_callback(self._discard_future)
+            return True
+        except Exception:
+            logger.exception("Failed to queue an event for Bidar")
+            return False
+
+    def _discard_future(self, future):
+        with self._lock:
+            self._futures.discard(future)
+        try:
+            future.result()
+        except Exception:
+            logger.exception("Background event submission failed")
+
+    def capture_event(self, payload, level="info"):
+        try:
+            level = level.lower()
+            if not self._enabled(level):
+                return False
+            safe_payload = redact_mapping(payload if isinstance(payload, dict) else {"data": payload})
+            fingerprint = self._fingerprint(safe_payload, level)
+            if self._is_duplicate(fingerprint):
+                return False
+            event = {
+                "level": level,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "project_name": self.config.project_name,
+                "environment": self.config.environment,
+                "runtime": {
+                    "language": "python",
+                    "python_version": platform.python_version(),
+                    "implementation": sys.implementation.name,
+                },
+                **safe_payload,
+            }
+            return self._submit(event)
+        except Exception:
+            logger.exception("Failed to prepare a Bidar event")
+            return False
+
+    def capture_exception(self, error, *, request=None, extra=None):
+        try:
+            payload = {
+                "exception_type": type(error).__name__,
+                "exception_message": str(error),
+                "traceback": "".join(
+                    traceback.format_exception(type(error), error, error.__traceback__)
+                ),
+            }
+            if request is not None:
+                payload["request"] = request
+            if extra:
+                payload["extra"] = redact_mapping(extra)
+            return self.capture_event(payload, level="error")
+        except Exception:
+            logger.exception("Failed to capture an exception")
+            return False
+
+    def capture_message(self, message, level="info", *, extra=None):
+        try:
+            payload = {"message": str(message)}
+            if extra:
+                payload["extra"] = redact_mapping(extra)
+            return self.capture_event(payload, level=level)
+        except Exception:
+            logger.exception("Failed to capture a message")
+            return False
+
+    def flush(self):
+        try:
+            with self._lock:
+                pending = list(self._futures)
+            if pending:
+                wait(pending, timeout=self.config.timeout + 1)
+        except Exception:
+            logger.exception("Failed while flushing Bidar events")
+
+    def shutdown(self):
+        if self._closed:
+            return
+        self.flush()
+        self._closed = True
+        try:
+            self.executor.shutdown(wait=False, cancel_futures=False)
+        except TypeError:
+            self.executor.shutdown(wait=False)
+        except Exception:
+            logger.exception("Failed to shut down the Bidar executor")
+        self.transport.close()
+
+
+def init(
+    *,
+    url,
+    access_key,
+    log_level="error",
+    project_name=None,
+    environment="Production",
+    timeout=3.0,
+    enabled=True,
+    middleware_enabled=True,
+    capture_request_body=False,
+    deduplication_window=30.0,
+    max_workers=2,
+):
+    global _client
+    config = Config(
+        url=url,
+        access_key=access_key,
+        log_level=log_level,
+        project_name=project_name,
+        environment=environment,
+        timeout=timeout,
+        enabled=enabled,
+        middleware_enabled=middleware_enabled,
+        capture_request_body=capture_request_body,
+        deduplication_window=deduplication_window,
+        max_workers=max_workers,
+    )
+    new_client = BidarClient(config)
+    with _client_lock:
+        old_client = _client
+        _client = new_client
+    if old_client is not None:
+        old_client.shutdown()
+    return new_client
+
+
+def get_client():
+    with _client_lock:
+        return _client
+
+
+def _get_client():
+    client = get_client()
+    if client is None:
+        logger.warning("Bidar SDK is not initialized; call bidar.init() first")
+    return client
+
+
+def capture_exception(error, **kwargs):
+    client = _get_client()
+    return client.capture_exception(error, **kwargs) if client else False
+
+
+def capture_message(message, level="info", **kwargs):
+    client = _get_client()
+    return client.capture_message(message, level=level, **kwargs) if client else False
+
+
+def capture_event(payload, level="info"):
+    client = _get_client()
+    return client.capture_event(payload, level=level) if client else False
+
+
+def flush():
+    client = _get_client()
+    return client.flush() if client else None
+
+
+def shutdown():
+    global _client
+    with _client_lock:
+        client = _client
+        _client = None
+    if client is not None:
+        client.shutdown()

bidar-0.1.0/bidar/config.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+
+VALID_LEVELS = {"info", "warning", "error"}
+
+
+@dataclass
+class Config:
+    url: str
+    access_key: str
+    log_level: str = "error"
+    project_name: str = None
+    environment: str = "Production"
+    timeout: float = 3.0
+    enabled: bool = True
+    middleware_enabled: bool = True
+    capture_request_body: bool = False
+    deduplication_window: float = 30.0
+    max_workers: int = 2
+
+    def __post_init__(self):
+        self.log_level = self.log_level.lower()
+        if self.log_level not in VALID_LEVELS:
+            raise ValueError("log_level must be one of: info, warning, error")
+        if not self.url:
+            raise ValueError("url is required")
+        if not self.access_key:
+            raise ValueError("access_key is required")
+        if self.timeout <= 0:
+            raise ValueError("timeout must be greater than zero")
+        if self.deduplication_window < 0:
+            raise ValueError("deduplication_window cannot be negative")
+        if self.max_workers < 1:
+            raise ValueError("max_workers must be at least one")

bidar-0.1.0/bidar/middleware.py

@@ -0,0 +1,80 @@
+import json
+import logging
+
+from .client import capture_exception, get_client, init
+from .utils.sanitizers import redact_headers, redact_mapping
+
+logger = logging.getLogger("bidar")
+
+
+def _initialize_from_django_settings():
+    if get_client() is not None:
+        return get_client()
+    try:
+        from django.conf import settings
+
+        options = getattr(settings, "BIDAR_SDK", {})
+        if not options or not options.get("URL") or not options.get("ACCESS_KEY"):
+            return None
+        return init(
+            url=options["URL"],
+            access_key=options["ACCESS_KEY"],
+            log_level=options.get("LOG_LEVEL", "error"),
+            project_name=options.get("PROJECT_NAME"),
+            environment=options.get("ENVIRONMENT", "Production"),
+            timeout=options.get("TIMEOUT", 3.0),
+            enabled=options.get("ENABLED", True),
+            middleware_enabled=options.get("MIDDLEWARE_ENABLED", True),
+            capture_request_body=options.get("CAPTURE_REQUEST_BODY", False),
+            deduplication_window=options.get("DEDUPLICATION_WINDOW", 30.0),
+            max_workers=options.get("MAX_WORKERS", 2),
+        )
+    except Exception:
+        logger.exception("Could not initialize Bidar SDK from Django settings")
+        return None
+
+
+class BidarMiddleware:
+    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._report(request, exc)
+            raise
+
+    def _report(self, request, error):
+        try:
+            client = _initialize_from_django_settings()
+            if client is None:
+                return
+            if not client.config.enabled or not client.config.middleware_enabled:
+                return
+
+            request_data = {
+                "method": request.method,
+                "path": request.path,
+                "query_params": redact_mapping(request.GET.dict()),
+                "headers": redact_headers(request.headers),
+            }
+
+            if client.config.capture_request_body:
+                try:
+                    raw_body = request.body
+                    try:
+                        parsed_body = json.loads(raw_body.decode("utf-8"))
+                        request_data["input"] = redact_mapping(parsed_body)
+                    except (UnicodeDecodeError, json.JSONDecodeError):
+                        request_data["input"] = raw_body.decode("utf-8", errors="replace")[:10000]
+                except Exception:
+                    request_data["input"] = "[UNAVAILABLE]"
+
+            user = getattr(request, "user", None)
+            if user is not None and getattr(user, "is_authenticated", False):
+                request_data["user_id"] = str(user.pk)
+
+            capture_exception(error, request=request_data)
+        except Exception:
+            logger.exception("Bidar middleware failed while reporting an exception")

bidar-0.1.0/bidar/transport.py

@@ -0,0 +1,33 @@
+import logging
+import requests
+
+logger = logging.getLogger("bidar")
+
+
+class Transport:
+    def __init__(self, config):
+        self.config = config
+        self.session = requests.Session()
+
+    def send(self, payload):
+        try:
+            response = self.session.post(
+                self.config.url,
+                json=payload,
+                headers={
+                    "Content-Type": "application/json",
+                    "X-Bidar-Access-Key": self.config.access_key,
+                },
+                timeout=self.config.timeout,
+            )
+            response.raise_for_status()
+            return True
+        except Exception:
+            logger.exception("Failed to submit an event to Bidar")
+            return False
+
+    def close(self):
+        try:
+            self.session.close()
+        except Exception:
+            logger.exception("Failed to close the Bidar HTTP session")

bidar-0.1.0/bidar/utils/sanitizers.py

@@ -0,0 +1,28 @@
+SENSITIVE_PARTS = (
+    "authorization", "cookie", "password", "passwd", "token",
+    "secret", "api_key", "access_key", "refresh",
+)
+
+
+def redact_mapping(data):
+    if not isinstance(data, dict):
+        return data
+    cleaned = {}
+    for key, value in data.items():
+        key_text = str(key).lower().replace("-", "_")
+        if any(part in key_text for part in SENSITIVE_PARTS):
+            cleaned[key] = "[REDACTED]"
+        elif isinstance(value, dict):
+            cleaned[key] = redact_mapping(value)
+        elif isinstance(value, list):
+            cleaned[key] = [
+                redact_mapping(item) if isinstance(item, dict) else item
+                for item in value
+            ]
+        else:
+            cleaned[key] = value
+    return cleaned
+
+
+def redact_headers(headers):
+    return redact_mapping(dict(headers))

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

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: bidar
+Version: 0.1.0
+Summary: Background error reporting SDK for Python and Django
+Author-email: CyberHuginn <contact@cyberhuginn.com>
+Maintainer-email: CyberHuginn <contact@cyberhuginn.com>
+License: MIT
+Project-URL: Homepage, https://cyberhuginn.com
+Project-URL: Organization, https://fardadnoavar.ir
+Keywords: bidar,error-reporting,django,monitoring,sentry
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: django
+Requires-Dist: Django>=3.2; extra == "django"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-mock>=3; extra == "dev"
+Dynamic: license-file
+
+# bidar-sdk-python
+
+A lightweight error and event reporting SDK for Python applications, with optional Django integration. Reports are submitted in the background so application request handling does not wait for the remote API.
+
+**Author:** CyberHuginn  
+**Organization:** Fardad Noavar  
+**Website:** [cyberhuginn.com](https://cyberhuginn.com)  
+**Organization website:** [fardadnoavar.ir](https://fardadnoavar.ir)  
+**Contact:** contact@cyberhuginn.com
+
+## Installation
+
+```bash
+pip install bidar-sdk-python
+```
+
+For Django projects:
+
+```bash
+pip install "bidar-sdk-python[django]"
+```
+
+## Quick start
+
+```python
+import bidar
+
+bidar.init(
+    url="https://api.bidarhq.ir/api/v1/errors/",
+    access_key="YOUR_ACCESS_KEY",
+    project_name="billing-api",
+    environment="Production",
+    log_level="error",
+    timeout=3.0,
+)
+
+try:
+    run_job()
+except Exception as exc:
+    bidar.capture_exception(exc)
+```
+
+Reports are queued on a background worker. `capture_exception`, `capture_message`, and `capture_event` return immediately with a boolean indicating whether the event was accepted for processing.
+
+## Django integration
+
+Add the middleware to `settings.py`:
+
+```python
+MIDDLEWARE = [
+    # ...
+    "bidar.middleware.BidarMiddleware",
+]
+```
+
+Configure the SDK:
+
+```python
+BIDAR_SDK = {
+    "URL": "https://api.bidarhq.ir/api/v1/errors/",
+    "ACCESS_KEY": "YOUR_ACCESS_KEY",
+    "PROJECT_NAME": "my-django-app",
+    "ENVIRONMENT": "Production",
+    "LOG_LEVEL": "error",
+    "TIMEOUT": 3.0,
+    "ENABLED": True,
+    "MIDDLEWARE_ENABLED": True,
+    "CAPTURE_REQUEST_BODY": False,
+    "DEDUPLICATION_WINDOW": 30,
+    "MAX_WORKERS": 2,
+}
+```
+
+The middleware reports unhandled exceptions and re-raises the original exception. Set `MIDDLEWARE_ENABLED` to `False` to disable automatic middleware reporting without removing the middleware from `MIDDLEWARE`.
+
+The SDK is initialized lazily from `BIDAR_SDK` when the middleware first runs. You can also call `bidar_sdk.init(...)` explicitly during application startup.
+
+## Manual reporting
+
+```python
+import bidar
+
+bidar.capture_exception(error)
+
+bidar.capture_message(
+    "Payment provider is unavailable",
+    level="warning",
+)
+
+bidar.capture_event(
+    {"event": "subscription.renewal_failed", "customer_id": 42},
+    level="error",
+)
+```
+
+## Configuration
+
+| Option | Default | Description |
+|---|---:|---|
+| `url` | Required | HTTP endpoint that receives JSON POST reports |
+| `access_key` | Required | API key sent in `X-Bidar-Access-Key` |
+| `log_level` | `error` | One of `info`, `warning`, or `error` |
+| `project_name` | `None` | Project identifier attached to every event |
+| `environment` | `Production` | Deployment environment |
+| `timeout` | `3.0` | Outbound HTTP timeout in seconds |
+| `enabled` | `True` | Enables or disables all reporting |
+| `middleware_enabled` | `True` | Enables or disables Django middleware reporting |
+| `capture_request_body` | `False` | Opt-in request body capture |
+| `deduplication_window` | `30` | Suppresses identical events within this many seconds; set to `0` to disable |
+| `max_workers` | `2` | Number of background HTTP workers |
+
+Log levels are threshold-based: `info` accepts all levels, `warning` accepts warnings and errors, and `error` accepts errors only.
+
+## Reliability and privacy
+
+- Network requests run in a background thread pool.
+- HTTP failures, serialization errors, and worker failures are contained and do not propagate into application code.
+- `flush()` waits for submitted reports; `shutdown()` flushes and closes the client.
+- Duplicate reports with the same event fingerprint are suppressed during the configured deduplication window.
+- Authorization, cookies, passwords, tokens, secrets, and API-key-like fields are redacted.
+- Request bodies are not captured by default. Enable `CAPTURE_REQUEST_BODY` only after reviewing the data your application sends.
+- The SDK does not intentionally collect local variables or environment variables.
+
+## Lifecycle
+
+```python
+bidar_sdk.flush()
+bidar_sdk.shutdown()
+```
+
+Call `flush()` during controlled shutdown if pending reports should be given a chance to finish. `shutdown()` prevents further submissions until the SDK is initialized again.
+
+## License
+
+MIT

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

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+bidar/__init__.py
+bidar/client.py
+bidar/config.py
+bidar/middleware.py
+bidar/transport.py
+bidar.egg-info/PKG-INFO
+bidar.egg-info/SOURCES.txt
+bidar.egg-info/dependency_links.txt
+bidar.egg-info/requires.txt
+bidar.egg-info/top_level.txt
+bidar/utils/__init__.py
+bidar/utils/sanitizers.py
+tests/test_client.py
+tests/test_config.py
+tests/test_sanitizers.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,8 @@
+requests>=2.28
+
+[dev]
+pytest>=7
+pytest-mock>=3
+
+[django]
+Django>=3.2

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

@@ -0,0 +1 @@
+bidar

bidar-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bidar"
+version = "0.1.0"
+description = "Background error reporting SDK for Python and Django"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "CyberHuginn", email = "contact@cyberhuginn.com" }]
+maintainers = [{ name = "CyberHuginn", email = "contact@cyberhuginn.com" }]
+keywords = ["bidar", "error-reporting", "django", "monitoring", "sentry"]
+dependencies = ["requests>=2.28"]
+
+[project.urls]
+Homepage = "https://cyberhuginn.com"
+Organization = "https://fardadnoavar.ir"
+
+[project.optional-dependencies]
+django = ["Django>=3.2"]
+dev = ["pytest>=7", "pytest-mock>=3"]
+
+[tool.setuptools.packages.find]
+include = ["bidar*"]

bidar-0.1.0/setup.cfg

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

bidar-0.1.0/tests/test_client.py

@@ -0,0 +1,58 @@
+from bidar.client import BidarClient
+from bidar.config import Config
+
+
+class FakeTransport:
+    def __init__(self, config):
+        self.config = config
+        self.sent = []
+
+    def send(self, payload):
+        self.sent.append(payload)
+        return True
+
+    def close(self):
+        pass
+
+
+def make_client():
+    client = BidarClient(Config(
+        url="https://example.com",
+        access_key="test-key",
+        project_name="test-project",
+        environment="Development",
+        deduplication_window=10,
+    ))
+    client.transport.close()
+    client.transport = FakeTransport(client.config)
+    return client
+
+
+def test_event_contains_project_and_environment():
+    client = make_client()
+    assert client.capture_message("hello", level="info")
+    client.flush()
+    assert client.transport.sent[0]["project_name"] == "test-project"
+    assert client.transport.sent[0]["environment"] == "Development"
+    client.shutdown()
+
+
+def test_duplicate_events_are_suppressed():
+    client = make_client()
+    assert client.capture_message("same event", level="error")
+    assert client.capture_message("same event", level="error") is False
+    client.flush()
+    assert len(client.transport.sent) == 1
+    client.shutdown()
+
+
+def test_transport_failure_does_not_escape_capture():
+    client = make_client()
+
+    def broken_send(payload):
+        raise RuntimeError("network failure")
+
+    client.transport.send = broken_send
+    assert client.capture_message("failure", level="error")
+    client.flush()
+    client.shutdown()

bidar-0.1.0/tests/test_config.py

@@ -0,0 +1,13 @@
+import pytest
+
+from bidar.config import Config
+
+
+def test_config_rejects_invalid_log_level():
+    with pytest.raises(ValueError):
+        Config(url="https://example.com", access_key="key", log_level="debug")
+
+
+def test_config_accepts_supported_levels():
+    for level in ("info", "warning", "error"):
+        assert Config(url="https://example.com", access_key="key", log_level=level)

bidar-0.1.0/tests/test_sanitizers.py

@@ -0,0 +1,13 @@
+from bidar.utils.sanitizers import redact_mapping
+
+
+def test_redacts_sensitive_fields_recursively():
+    result = redact_mapping({
+        "password": "secret",
+        "nested": {"access_key": "abc", "name": "Alice"},
+        "items": [{"refresh_token": "xyz"}],
+    })
+    assert result["password"] == "[REDACTED]"
+    assert result["nested"]["access_key"] == "[REDACTED]"
+    assert result["nested"]["name"] == "Alice"
+    assert result["items"][0]["refresh_token"] == "[REDACTED]"