logsetu-django 0.1.0__py3-none-any.whl

logsetu/__init__.py

@@ -0,0 +1,41 @@
+"""LogSetu SDK for Django & DRF.
+
+Quick start (settings.py)::
+
+    LOGGING = {
+        "version": 1,
+        "handlers": {
+            "logsetu": {
+                "class": "logsetu.handler.LogSetuHandler",
+                "api_key": env("LOGSETU_API_KEY"),
+                "endpoint": env("LOGSETU_ENDPOINT"),
+                "environment": "production",
+                "source": "django-backend",
+                "level": "WARNING",
+            },
+        },
+        "root": {"handlers": ["logsetu"], "level": "INFO"},
+    }
+    MIDDLEWARE = [..., "logsetu.middleware.LogSetuMiddleware"]
+"""
+
+from .client import LogSetuClient, get_client, __version__
+from .context import get_request_context, update_request_context
+
+__all__ = [
+    "LogSetuClient",
+    "get_client",
+    "get_request_context",
+    "update_request_context",
+    "capture_exception",
+    "__version__",
+]
+
+default_app_config = "logsetu.apps.LogSetuConfig"
+
+
+def capture_exception(exc: BaseException, message: str = "", **meta: object) -> None:
+    """Report an exception through the configured ``LogSetuHandler`` (via the stdlib logger)."""
+    import logging
+
+    logging.getLogger("logsetu.capture").error(message or f"{type(exc).__name__}: {exc}", exc_info=exc, extra=meta)

logsetu/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class LogSetuConfig(AppConfig):
+    name = "logsetu"
+    verbose_name = "LogSetu"

logsetu/client.py

@@ -0,0 +1,250 @@
+"""Thread-safe, batching HTTP client for the LogSetu ingestion API.
+
+Uses only the standard library so the package has zero runtime dependencies.
+Never raises into the host application: transport failures are reported once on
+stderr and the affected batch is dropped.
+"""
+
+from __future__ import annotations
+
+import atexit
+import json
+import queue
+import random
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Dict, List, Optional, Tuple
+
+__version__ = "0.1.0"
+
+LogDict = Dict[str, Any]
+
+_MAX_BATCH = 500
+_FLUSH: Any = object()  # queue sentinel: send whatever is buffered now
+_STOP: Any = object()  # queue sentinel: send and exit
+
+
+def to_json_safe(value: Any, depth: int = 0) -> Any:
+    """Coerce arbitrary values into something ``json.dumps`` accepts."""
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if depth > 6:
+        return repr(value)
+    if isinstance(value, dict):
+        return {str(k): to_json_safe(v, depth + 1) for k, v in list(value.items())[:200]}
+    if isinstance(value, (list, tuple, set, frozenset)):
+        return [to_json_safe(v, depth + 1) for v in list(value)[:200]]
+    if isinstance(value, bytes):
+        return value.decode("utf-8", errors="replace")[:2000]
+    if hasattr(value, "isoformat"):
+        try:
+            return value.isoformat()
+        except Exception:  # pragma: no cover
+            pass
+    return repr(value)
+
+
+class LogSetuClient:
+    """Queues log dicts and ships them in batches from a background daemon thread."""
+
+    def __init__(
+        self,
+        api_key: str,
+        endpoint: str,
+        *,
+        environment: str = "production",
+        source: str = "django",
+        flush_interval: float = 2.0,
+        batch_size: int = 10,
+        max_queue_size: int = 1000,
+        max_retries: int = 3,
+        timeout: float = 5.0,
+        debug: bool = False,
+        enabled: bool = True,
+    ) -> None:
+        self.api_key = api_key or ""
+        self.endpoint = (endpoint or "").rstrip("/")
+        self.ingest_url = f"{self.endpoint}/api/v1/ingest"
+        self.environment = environment
+        self.source = source
+        self.flush_interval = max(0.05, float(flush_interval))
+        self.batch_size = max(1, min(int(batch_size), _MAX_BATCH))
+        self.max_queue_size = max(1, int(max_queue_size))
+        self.max_retries = max(0, int(max_retries))
+        self.timeout = float(timeout)
+        self.debug = debug
+        self.enabled = bool(enabled and self.api_key and self.endpoint)
+
+        self._queue: "queue.Queue[Any]" = queue.Queue(maxsize=self.max_queue_size + 2)
+        self._dropped = 0
+        self._warned = False
+        self._lock = threading.Lock()
+        self._idle = threading.Event()
+        self._idle.set()
+        self._stopped = False
+        self._thread: Optional[threading.Thread] = None
+
+        if not self.enabled:
+            if enabled:
+                self._warn("api_key/endpoint not configured; logs will not be sent")
+            return
+        self._thread = threading.Thread(target=self._run, name="logsetu-worker", daemon=True)
+        self._thread.start()
+        atexit.register(self.close)
+
+    # ---------- public ----------
+
+    def log(
+        self,
+        level: str,
+        message: str,
+        meta: Optional[Dict[str, Any]] = None,
+        *,
+        timestamp: Optional[str] = None,
+        source: Optional[str] = None,
+        environment: Optional[str] = None,
+    ) -> None:
+        if not self.enabled or self._stopped:
+            return
+        entry: LogDict = {
+            "level": level,
+            "message": str(message)[:10_000],
+            "source": source or self.source,
+            "environment": environment or self.environment,
+        }
+        if timestamp:
+            entry["timestamp"] = timestamp
+        if meta:
+            entry["meta"] = to_json_safe(meta)
+        self.enqueue(entry)
+
+    def enqueue(self, entry: LogDict) -> None:
+        if not self.enabled or self._stopped:
+            return
+        self._idle.clear()
+        with self._lock:
+            if self._queue.qsize() >= self.max_queue_size:
+                # Drop the oldest to make room; a log SDK must never block the request cycle.
+                try:
+                    self._queue.get_nowait()
+                except queue.Empty:  # pragma: no cover
+                    pass
+                self._dropped += 1
+            try:
+                self._queue.put_nowait(entry)
+            except queue.Full:  # pragma: no cover
+                self._dropped += 1
+
+    def flush(self, timeout: Optional[float] = 10.0) -> bool:
+        """Block until everything currently queued has been sent (or *timeout* elapses)."""
+        if not self.enabled or self._stopped:
+            return True
+        self._idle.clear()
+        try:
+            self._queue.put_nowait(_FLUSH)
+        except queue.Full:  # pragma: no cover
+            pass
+        return self._idle.wait(timeout)
+
+    def close(self) -> None:
+        if not self.enabled or self._stopped:
+            return
+        self._stopped = True
+        self._queue.put(_STOP)
+        if self._thread is not None:
+            self._thread.join(timeout=10.0)
+
+    @property
+    def dropped(self) -> int:
+        return self._dropped
+
+    # ---------- worker ----------
+
+    def _run(self) -> None:
+        batch: List[LogDict] = []
+        deadline = time.monotonic() + self.flush_interval
+        while True:
+            try:
+                item = self._queue.get(timeout=max(0.0, deadline - time.monotonic()))
+            except queue.Empty:
+                item = _FLUSH
+            if item is _STOP:
+                self._send(batch + self._drain())
+                self._idle.set()
+                return
+            if item is not _FLUSH:
+                batch.append(item)
+            if batch and (len(batch) >= self.batch_size or item is _FLUSH):
+                self._send(batch + self._drain(_MAX_BATCH - len(batch)))
+                batch = []
+            if item is _FLUSH or not batch:
+                deadline = time.monotonic() + self.flush_interval
+            if not batch and self._queue.empty():
+                self._idle.set()
+
+    def _drain(self, limit: int = _MAX_BATCH) -> List[LogDict]:
+        out: List[LogDict] = []
+        while len(out) < limit:
+            try:
+                more = self._queue.get_nowait()
+            except queue.Empty:
+                break
+            if more is _STOP:
+                self._queue.put_nowait(_STOP)
+                break
+            if more is not _FLUSH:
+                out.append(more)
+        return out
+
+    def _send(self, batch: List[LogDict]) -> None:
+        if not batch:
+            return
+        body = json.dumps(batch, default=str).encode("utf-8")
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "User-Agent": f"logsetu-django/{__version__}",
+        }
+        last_error = "unknown error"
+        for attempt in range(self.max_retries + 1):
+            try:
+                req = urllib.request.Request(self.ingest_url, data=body, headers=headers, method="POST")
+                with urllib.request.urlopen(req, timeout=self.timeout) as res:  # noqa: S310 - user-configured URL
+                    if 200 <= res.status < 300:
+                        return
+                    last_error = f"HTTP {res.status}"
+            except urllib.error.HTTPError as e:
+                if e.code < 500 and e.code != 429:
+                    self._warn(f"server rejected batch (HTTP {e.code}); dropped {len(batch)} logs")
+                    return
+                last_error = f"HTTP {e.code}"
+            except Exception as e:  # network errors, timeouts, DNS
+                last_error = repr(e)
+            if attempt < self.max_retries:
+                time.sleep(min(30.0, 0.5 * (2**attempt)) + random.random() * 0.25)
+        self._warn(f"giving up after {self.max_retries + 1} attempts ({last_error}); dropped {len(batch)} logs")
+
+    def _warn(self, msg: str) -> None:
+        # Deliberately bypass the logging module: the LogSetu handler may be attached to the root logger.
+        if self.debug or not self._warned:
+            self._warned = True
+            suffix = "" if self.debug else " (further transport warnings suppressed; set debug=True to see them)"
+            sys.stderr.write(f"[logsetu] {msg}{suffix}\n")
+
+
+_registry: Dict[Tuple[str, str], LogSetuClient] = {}
+_registry_lock = threading.Lock()
+
+
+def get_client(api_key: str, endpoint: str, **kwargs: Any) -> LogSetuClient:
+    """Return a shared client per (api_key, endpoint) so the handler and middleware use one queue."""
+    key = (api_key or "", (endpoint or "").rstrip("/"))
+    with _registry_lock:
+        client = _registry.get(key)
+        if client is None or client._stopped:
+            client = LogSetuClient(api_key, endpoint, **kwargs)
+            _registry[key] = client
+        return client

logsetu/conf.py

@@ -0,0 +1,41 @@
+"""Configuration helpers: resolve callables from dotted paths and read ``settings.LOGSETU``."""
+
+from __future__ import annotations
+
+import importlib
+from typing import Any, Callable, Dict, Optional, Union
+
+TenantGetter = Callable[[Any], Optional[str]]
+
+DEFAULT_REDACT_HEADERS = ("authorization", "cookie", "set-cookie", "x-api-key", "x-csrftoken", "proxy-authorization")
+
+
+def import_callable(value: Union[str, Callable[..., Any], None]) -> Optional[Callable[..., Any]]:
+    """Accept a callable or a dotted path like ``"myapp.tenants.get_tenant_id"``."""
+    if value is None:
+        return None
+    if callable(value):
+        return value
+    if not isinstance(value, str):
+        raise TypeError(f"expected callable or dotted path, got {type(value)!r}")
+    module_path, _, attr = value.rpartition(".")
+    if not module_path:
+        raise ImportError(f"'{value}' is not a dotted path")
+    module = importlib.import_module(module_path)
+    try:
+        return getattr(module, attr)
+    except AttributeError as e:
+        raise ImportError(f"module '{module_path}' has no attribute '{attr}'") from e
+
+
+def django_settings() -> Dict[str, Any]:
+    """``settings.LOGSETU`` if Django is configured, else ``{}``. Never raises."""
+    try:
+        from django.conf import settings
+
+        if not settings.configured:
+            return {}
+        value = getattr(settings, "LOGSETU", None)
+        return dict(value) if isinstance(value, dict) else {}
+    except Exception:
+        return {}

logsetu/context.py

@@ -0,0 +1,36 @@
+"""Per-request context (path, user, tenant, request id) shared between middleware and handler.
+
+Backed by ``contextvars`` so it works for both sync (threaded) and async Django.
+"""
+
+from __future__ import annotations
+
+import contextvars
+from typing import Any, Dict, Optional
+
+_request_context: contextvars.ContextVar[Optional[Dict[str, Any]]] = contextvars.ContextVar(
+    "logsetu_request_context", default=None
+)
+
+
+def set_request_context(ctx: Optional[Dict[str, Any]]) -> contextvars.Token:
+    return _request_context.set(ctx)
+
+
+def reset_request_context(token: contextvars.Token) -> None:
+    try:
+        _request_context.reset(token)
+    except ValueError:  # token from another context (async edge cases)
+        _request_context.set(None)
+
+
+def get_request_context() -> Dict[str, Any]:
+    return dict(_request_context.get() or {})
+
+
+def update_request_context(**fields: Any) -> None:
+    """Attach extra fields (e.g. tenant_id) to every log emitted during the current request."""
+    current = _request_context.get()
+    merged = dict(current or {})
+    merged.update(fields)
+    _request_context.set(merged)

logsetu/handler.py

@@ -0,0 +1,188 @@
+"""``logging.Handler`` that ships records to LogSetu.
+
+Configure it through Django's ``LOGGING`` dict (or ``logging.config.dictConfig``)::
+
+    "handlers": {
+        "logsetu": {
+            "class": "logsetu.handler.LogSetuHandler",
+            "api_key": env("LOGSETU_API_KEY"),
+            "endpoint": env("LOGSETU_ENDPOINT"),
+            "environment": "production",
+            "source": "django-backend",
+            "level": "WARNING",
+            # optional:
+            # "get_tenant_id": "myapp.tenants.get_tenant_id",
+        },
+    },
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from typing import Any, Callable, Dict, Optional, Union
+
+from .client import LogSetuClient, get_client
+from .conf import TenantGetter, django_settings, import_callable
+from .context import get_request_context
+
+LEVEL_MAP = {
+    logging.DEBUG: "debug",
+    logging.INFO: "info",
+    logging.WARNING: "warn",
+    logging.ERROR: "error",
+    logging.CRITICAL: "fatal",
+}
+
+# Attributes every LogRecord has; anything else came from ``extra=`` and is forwarded as meta.
+_STANDARD_ATTRS = frozenset(
+    {
+        "name", "msg", "args", "levelname", "levelno", "pathname", "filename", "module", "exc_info", "exc_text",
+        "stack_info", "lineno", "funcName", "created", "msecs", "relativeCreated", "thread", "threadName",
+        "processName", "process", "message", "asctime", "taskName",
+    }
+)
+
+
+def level_name(levelno: int) -> str:
+    if levelno >= logging.CRITICAL:
+        return "fatal"
+    if levelno >= logging.ERROR:
+        return "error"
+    if levelno >= logging.WARNING:
+        return "warn"
+    if levelno >= logging.INFO:
+        return "info"
+    return "debug"
+
+
+class LogSetuHandler(logging.Handler):
+    """Send Python logging records to a LogSetu server, batched on a background thread."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        *,
+        environment: Optional[str] = None,
+        source: Optional[str] = None,
+        level: Union[int, str] = logging.NOTSET,
+        get_tenant_id: Union[str, TenantGetter, None] = None,
+        include_extra: bool = True,
+        include_request_context: bool = True,
+        flush_interval: float = 2.0,
+        batch_size: int = 10,
+        max_queue_size: int = 1000,
+        max_retries: int = 3,
+        timeout: float = 5.0,
+        debug: bool = False,
+        client: Optional[LogSetuClient] = None,
+    ) -> None:
+        super().__init__(level)
+        cfg = django_settings()
+        self.api_key = api_key or cfg.get("API_KEY") or ""
+        self.endpoint = endpoint or cfg.get("ENDPOINT") or ""
+        self.environment = environment or cfg.get("ENVIRONMENT") or "production"
+        self.source = source or cfg.get("SOURCE") or "django"
+        self.include_extra = include_extra
+        self.include_request_context = include_request_context
+        self.get_tenant_id: Optional[Callable[[Any], Optional[str]]] = import_callable(
+            get_tenant_id or cfg.get("GET_TENANT_ID")
+        )
+        self.client = client or get_client(
+            self.api_key,
+            self.endpoint,
+            environment=self.environment,
+            source=self.source,
+            flush_interval=flush_interval,
+            batch_size=batch_size,
+            max_queue_size=max_queue_size,
+            max_retries=max_retries,
+            timeout=timeout,
+            debug=bool(debug or cfg.get("DEBUG", False)),
+        )
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            # Django's own ``django.request`` logger re-logs 5xx responses; skip those the
+            # middleware already reported with richer context.
+            req = record.__dict__.get("request")
+            if req is not None and getattr(req, "_logsetu_reported", False):
+                return
+            self.client.enqueue(self.build_entry(record))
+        except Exception:
+            self.handleError(record)
+
+    def build_entry(self, record: logging.LogRecord) -> Dict[str, Any]:
+        meta: Dict[str, Any] = {
+            "logger": record.name,
+            "module": record.module,
+            "function": record.funcName,
+            "line": record.lineno,
+            "process": record.process,
+            "thread": record.threadName,
+        }
+        if record.exc_info:
+            exc_type = record.exc_info[0]
+            meta["exception"] = exc_type.__name__ if exc_type else None
+            if not record.exc_text:
+                record.exc_text = logging.Formatter().formatException(record.exc_info)
+        if record.exc_text:
+            meta["stack"] = record.exc_text
+        if record.stack_info:
+            meta["stack_info"] = record.stack_info
+        if self.include_extra:
+            for key, value in record.__dict__.items():
+                if key not in _STANDARD_ATTRS and not key.startswith("_") and key not in meta:
+                    meta[key] = _summarize_request(value) if key == "request" else value
+        if self.include_request_context:
+            ctx = get_request_context()
+            if ctx:
+                meta["request"] = ctx
+                if "tenant_id" in ctx and "tenant_id" not in meta:
+                    meta["tenant_id"] = ctx["tenant_id"]
+        # Allow logger.info("...", extra={"source": "celery"}) to override per-record.
+        source = meta.pop("source", None) or self.source
+        environment = meta.pop("environment", None) or self.environment
+        return {
+            "level": level_name(record.levelno),
+            "message": self.format_message(record),
+            "source": str(source),
+            "environment": str(environment),
+            "timestamp": datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(),
+            "meta": _json_safe(meta),
+        }
+
+    def format_message(self, record: logging.LogRecord) -> str:
+        try:
+            msg = record.getMessage()
+        except Exception:
+            msg = str(record.msg)
+        return msg[:10_000]
+
+    def flush(self) -> None:
+        self.client.flush(timeout=5.0)
+
+    def close(self) -> None:
+        try:
+            self.client.flush(timeout=5.0)
+        finally:
+            super().close()
+
+
+def _summarize_request(value: Any) -> Any:
+    """``extra={"request": HttpRequest}`` (as Django does) → a small dict instead of a repr."""
+    meta = getattr(value, "META", None)
+    if not isinstance(meta, dict):
+        return value
+    return {
+        "method": getattr(value, "method", None),
+        "path": getattr(value, "path", None),
+        "query": meta.get("QUERY_STRING", "")[:2000],
+    }
+
+
+def _json_safe(meta: Dict[str, Any]) -> Dict[str, Any]:
+    from .client import to_json_safe
+
+    return {k: to_json_safe(v) for k, v in meta.items() if v is not None}

logsetu/middleware.py

@@ -0,0 +1,186 @@
+"""Django middleware: attaches request context to every log and reports unhandled exceptions.
+
+Add it to ``MIDDLEWARE`` (after ``AuthenticationMiddleware`` if you want user ids)::
+
+    MIDDLEWARE = [..., "logsetu.middleware.LogSetuMiddleware"]
+
+It reuses the client of a configured ``LogSetuHandler``; alternatively configure it directly::
+
+    LOGSETU = {
+        "API_KEY": env("LOGSETU_API_KEY"),
+        "ENDPOINT": env("LOGSETU_ENDPOINT"),
+        "ENVIRONMENT": "production",
+        "SOURCE": "django-backend",
+        "GET_TENANT_ID": "myapp.tenants.get_tenant_id",   # callable(request) -> str | None
+        "REDACT_HEADERS": ["authorization", "cookie"],     # default list already covers the usual suspects
+        "CAPTURE_5XX": True,                                # also log responses with status >= 500 that didn't raise
+    }
+"""
+
+from __future__ import annotations
+
+import logging
+import traceback
+import uuid
+from typing import Any, Callable, Dict, Optional
+
+from django.utils.deprecation import MiddlewareMixin
+
+from .client import LogSetuClient, get_client
+from .conf import DEFAULT_REDACT_HEADERS, django_settings, import_callable
+from .context import get_request_context, reset_request_context, set_request_context
+from .handler import LogSetuHandler
+
+
+def _find_handler() -> Optional[LogSetuHandler]:
+    """The first LogSetuHandler attached to any configured logger (root first)."""
+    loggers = [logging.getLogger()] + [
+        lg for lg in logging.Logger.manager.loggerDict.values() if isinstance(lg, logging.Logger)
+    ]
+    for lg in loggers:
+        for h in lg.handlers:
+            if isinstance(h, LogSetuHandler):
+                return h
+    return None
+
+
+class LogSetuMiddleware(MiddlewareMixin):
+    """Capture request metadata for every log line and report unhandled exceptions with full context."""
+
+    def __init__(self, get_response: Callable[..., Any]) -> None:
+        super().__init__(get_response)
+        cfg = django_settings()
+        handler = _find_handler()
+        self.client: LogSetuClient = (
+            handler.client
+            if handler is not None
+            else get_client(
+                cfg.get("API_KEY", ""),
+                cfg.get("ENDPOINT", ""),
+                environment=cfg.get("ENVIRONMENT", "production"),
+                source=cfg.get("SOURCE", "django"),
+                debug=bool(cfg.get("DEBUG", False)),
+            )
+        )
+        self.source: str = cfg.get("SOURCE") or (handler.source if handler else "django")
+        self.environment: str = cfg.get("ENVIRONMENT") or (handler.environment if handler else "production")
+        self.get_tenant_id = import_callable(cfg.get("GET_TENANT_ID")) or (handler.get_tenant_id if handler else None)
+        self.redact_headers = {h.lower() for h in cfg.get("REDACT_HEADERS", DEFAULT_REDACT_HEADERS)}
+        self.capture_5xx: bool = bool(cfg.get("CAPTURE_5XX", True))
+
+    # ---------- request lifecycle ----------
+
+    def process_request(self, request: Any) -> None:
+        ctx: Dict[str, Any] = {
+            "request_id": request.META.get("HTTP_X_REQUEST_ID") or uuid.uuid4().hex[:16],
+            "method": request.method,
+            "path": request.path,
+        }
+        ip = self._client_ip(request)
+        if ip:
+            ctx["ip"] = ip
+        tenant = self._tenant(request)
+        if tenant is not None:
+            ctx["tenant_id"] = tenant
+        request._logsetu_token = set_request_context(ctx)  # noqa: SLF001
+        request.logsetu_request_id = ctx["request_id"]
+
+    def process_response(self, request: Any, response: Any) -> Any:
+        try:
+            status = getattr(response, "status_code", 0)
+            if self.capture_5xx and status >= 500 and not getattr(request, "_logsetu_reported", False):
+                self._report(
+                    request,
+                    level="error",
+                    message=f"HTTP {status} on {request.method} {request.path}",
+                    extra={"status": status},
+                )
+                request._logsetu_reported = True  # noqa: SLF001
+        finally:
+            token = getattr(request, "_logsetu_token", None)
+            if token is not None:
+                reset_request_context(token)
+        return response
+
+    def process_exception(self, request: Any, exception: BaseException) -> None:
+        stack = "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))
+        self._report(
+            request,
+            level="error",
+            message=f"{type(exception).__name__}: {exception}",
+            extra={"exception": type(exception).__name__, "stack": stack},
+        )
+        request._logsetu_reported = True  # noqa: SLF001
+        return None  # let Django produce the 500 response as usual
+
+    # ---------- helpers ----------
+
+    def _report(self, request: Any, *, level: str, message: str, extra: Dict[str, Any]) -> None:
+        try:
+            meta: Dict[str, Any] = {**get_request_context(), **extra, "request": self.request_info(request)}
+            user = self.user_info(request)
+            if user:
+                meta["user"] = user
+            self.client.log(level, message, meta, source=self.source, environment=self.environment)
+        except Exception:  # never break the response cycle
+            pass
+
+    def request_info(self, request: Any) -> Dict[str, Any]:
+        info: Dict[str, Any] = {
+            "method": request.method,
+            "path": request.path,
+            "query": request.META.get("QUERY_STRING", "")[:2000],
+            "headers": self.redacted_headers(request),
+        }
+        ip = self._client_ip(request)
+        if ip:
+            info["ip"] = ip
+        try:
+            view = request.resolver_match.view_name if request.resolver_match else None
+            if view:
+                info["view"] = view
+        except Exception:
+            pass
+        return info
+
+    def redacted_headers(self, request: Any) -> Dict[str, str]:
+        out: Dict[str, str] = {}
+        headers = getattr(request, "headers", None)
+        items = headers.items() if headers is not None else (
+            (k[5:].replace("_", "-"), v) for k, v in request.META.items() if k.startswith("HTTP_")
+        )
+        for name, value in items:
+            key = str(name).lower()
+            out[key] = "[REDACTED]" if key in self.redact_headers else str(value)[:500]
+        return out
+
+    def user_info(self, request: Any) -> Optional[Dict[str, Any]]:
+        user = getattr(request, "user", None)
+        if user is None:
+            return None
+        try:
+            if not getattr(user, "is_authenticated", False):
+                return None
+            info: Dict[str, Any] = {"id": getattr(user, "pk", None)}
+            username = getattr(user, "get_username", None)
+            if callable(username):
+                info["username"] = username()
+            return info
+        except Exception:
+            return None
+
+    def _tenant(self, request: Any) -> Optional[str]:
+        if self.get_tenant_id is None:
+            return None
+        try:
+            value = self.get_tenant_id(request)
+            return None if value is None else str(value)
+        except Exception:
+            return None
+
+    @staticmethod
+    def _client_ip(request: Any) -> Optional[str]:
+        forwarded = request.META.get("HTTP_X_FORWARDED_FOR")
+        if forwarded:
+            return forwarded.split(",")[0].strip()
+        return request.META.get("REMOTE_ADDR")

logsetu_django-0.1.0.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.5
+Name: logsetu-django
+Version: 0.1.0
+Summary: LogSetu SDK for Django & DRF — ship Python logging records and request errors to your self-hosted LogSetu server
+Project-URL: Homepage, https://github.com/itsrajverma/logsetu
+Project-URL: Documentation, https://github.com/itsrajverma/logsetu/tree/main/docs
+Project-URL: Repository, https://github.com/itsrajverma/logsetu
+Project-URL: Issues, https://github.com/itsrajverma/logsetu/issues
+Author: Raj Verma
+License-Expression: MIT
+License-File: LICENSE
+Keywords: django,drf,error-tracking,logging,logsetu,self-hosted,sentry-alternative
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Logging
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: django>=3.2; extra == 'dev'
+Requires-Dist: pytest-django>=4.8; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: django
+Requires-Dist: django>=3.2; extra == 'django'
+Description-Content-Type: text/markdown
+
+# logsetu-django
+
+Ship Django / DRF logs and unhandled errors to your self-hosted [LogSetu](https://github.com/itsrajverma/logsetu) server.
+Zero runtime dependencies, non-blocking (background thread + batching), and it never crashes your app if the log server is down.
+
+```bash
+pip install logsetu-django
+```
+
+## Setup (2 minutes)
+
+```python
+# settings.py
+INSTALLED_APPS = [..., "logsetu"]  # optional, but nice for discoverability
+
+LOGGING = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "handlers": {
+        "logsetu": {
+            "class": "logsetu.handler.LogSetuHandler",
+            "api_key": env("LOGSETU_API_KEY"),        # from the LogSetu dashboard → Projects
+            "endpoint": env("LOGSETU_ENDPOINT"),      # e.g. https://logs.example.com
+            "environment": env("ENVIRONMENT", default="production"),
+            "source": "django-backend",
+            "level": "WARNING",
+        },
+    },
+    "root": {"handlers": ["logsetu"], "level": "INFO"},
+}
+
+MIDDLEWARE = [
+    ...,
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "logsetu.middleware.LogSetuMiddleware",   # after auth middleware so user ids are captured
+]
+```
+
+That's it. Every `logging` call at or above the handler's level is sent to LogSetu, and the middleware
+reports unhandled exceptions (and 5xx responses) with the request path, method, view, user, redacted headers and full traceback.
+
+```python
+import logging
+log = logging.getLogger(__name__)
+
+log.warning("Checkout is slow", extra={"duration_ms": 1830, "cart_items": 12})
+try:
+    charge(card)
+except PaymentError:
+    log.exception("Payment failed")          # traceback is attached automatically
+```
+
+## Multi-tenant apps
+
+Tag every log with the current tenant by pointing the SDK at a callable `(request) -> str | None`:
+
+```python
+# settings.py
+LOGGING["handlers"]["logsetu"]["get_tenant_id"] = "myapp.tenants.get_tenant_id"
+
+# myapp/tenants.py
+def get_tenant_id(request):
+    return getattr(request, "tenant", None) and request.tenant.slug
+```
+
+Or, from anywhere inside a request (e.g. after you resolve the tenant in your own middleware):
+
+```python
+from logsetu import update_request_context
+update_request_context(tenant_id=tenant.slug, plan=tenant.plan)
+```
+
+## Handler options
+
+| Option | Default | Description |
+|---|---|---|
+| `api_key` / `endpoint` | — | Required (or set `LOGSETU = {"API_KEY": ..., "ENDPOINT": ...}` in settings) |
+| `environment` | `"production"` | Tag on every log |
+| `source` | `"django"` | Tag on every log; override per record with `extra={"source": "celery"}` |
+| `get_tenant_id` | `None` | Dotted path or callable `(request) -> str` |
+| `include_extra` | `True` | Forward `extra={...}` fields as metadata |
+| `include_request_context` | `True` | Attach request id / path / method / tenant set by the middleware |
+| `flush_interval` | `2.0` | Seconds between background flushes |
+| `batch_size` | `10` | Flush as soon as this many logs are queued |
+| `max_queue_size` | `1000` | Drop oldest logs beyond this |
+| `max_retries` | `3` | Retries with exponential backoff on 5xx / network errors |
+| `timeout` | `5.0` | HTTP timeout in seconds |
+| `debug` | `False` | Print every transport failure to stderr (otherwise only the first) |
+
+## Middleware options (`settings.LOGSETU`)
+
+The middleware reuses the client and options of a configured `LogSetuHandler`. Without a handler it can run standalone:
+
+```python
+LOGSETU = {
+    "API_KEY": env("LOGSETU_API_KEY"),
+    "ENDPOINT": env("LOGSETU_ENDPOINT"),
+    "ENVIRONMENT": "production",
+    "SOURCE": "django-backend",
+    "GET_TENANT_ID": "myapp.tenants.get_tenant_id",
+    "REDACT_HEADERS": ["authorization", "cookie", "x-api-key"],  # defaults already cover these
+    "CAPTURE_5XX": True,   # also report 5xx responses that didn't raise
+}
+```
+
+Every request gets a `request_id` (taken from `X-Request-ID` if present, otherwise generated) which is
+attached to all logs emitted during that request and exposed as `request.logsetu_request_id`.
+
+## Guarantees
+
+- **Never blocks** the request cycle: `emit()` only appends to an in-memory queue.
+- **Never raises** into your app: transport errors are printed once to stderr, then suppressed.
+- **Never leaks secrets**: `Authorization`, `Cookie`, `X-Api-Key`, `X-CSRFToken` and `Proxy-Authorization` are redacted.
+- **Never loses the last logs** on shutdown: the queue is flushed via `atexit`.
+
+## Celery / management commands
+
+Nothing special — the handler works anywhere Python's `logging` does. Set `extra={"source": "celery"}` to distinguish
+workers, or configure a second handler with a different `source`.
+
+## License
+
+MIT

logsetu_django-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+logsetu/__init__.py,sha256=YzywcF8O7SfPcR3tOMSHfILwTdKBBQ4TcK-RF7Sk1-Y,1247
+logsetu/apps.py,sha256=IHOVQ8M-3QyZWBVckt-YdgQ7P8I_SvFn_Pl4aWLQmEQ,118
+logsetu/client.py,sha256=4HuC7TsHPFC8MjxpDqE8j7V_PrR7qevLQjznYD6l_WA,9050
+logsetu/conf.py,sha256=W6kFaFRRl6I3g_LtJr7tTsBVG8hFlNyQ-4KsD_zoWAk,1497
+logsetu/context.py,sha256=swmn2NAbvKQSLEI9xWLf3zv-xin7AJQoljw_LGgNUdY,1120
+logsetu/handler.py,sha256=vJVlP4SKQv4AFJ8jw_l5DbhZiDGVaaBtNbz14Nmly5Y,6844
+logsetu/middleware.py,sha256=YnYFdUdkr1V36RWMoNNdJ1Ydt2vJfsr3iZtaduM-ksg,7502
+logsetu/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+logsetu_django-0.1.0.dist-info/METADATA,sha256=6WuXuEAO79uK7YZP32sKM8HtRukp6Zfdv-lVY86ek7E,5903
+logsetu_django-0.1.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+logsetu_django-0.1.0.dist-info/licenses/LICENSE,sha256=VSNbiwzQEl94c_0klrG3xFGSyCCuTPklb97l9I1e3LU,1066
+logsetu_django-0.1.0.dist-info/RECORD,,

logsetu_django-0.1.0.dist-info/WHEEL

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

logsetu_django-0.1.0.dist-info/licenses/LICENSE

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