logsetu 0.3.0__py3-none-any.whl

logsetu/__init__.py

@@ -0,0 +1,41 @@
+"""LogSetu SDK for Python: Django & DRF, Flask (``logsetu.flask``) and FastAPI / ASGI (``logsetu.fastapi``).
+
+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/asgi.py

@@ -0,0 +1,151 @@
+"""ASGI middleware for FastAPI, Starlette, Litestar, Quart and any other ASGI app.
+
+::
+
+    from fastapi import FastAPI
+    from logsetu.asgi import LogSetuMiddleware
+
+    app = FastAPI()
+    app.add_middleware(
+        LogSetuMiddleware,
+        api_key=os.environ["LOGSETU_API_KEY"],
+        endpoint=os.environ["LOGSETU_ENDPOINT"],
+        source="fastapi",
+    )
+
+Every log emitted while a request is handled (through stdlib ``logging``) carries the request id, method and path;
+unhandled exceptions and 5xx responses are reported with redacted headers. No dependency on Starlette itself.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from typing import Any, Awaitable, Callable, Dict, Iterable, MutableMapping, Optional
+
+from .client import LogSetuClient
+from .conf import DEFAULT_REDACT_HEADERS, import_callable
+from .context import get_request_context, reset_request_context, set_request_context
+from .web import attach_handler, client_ip, exception_meta, make_client, mark_reported, redact, request_id
+
+__all__ = ["LogSetuMiddleware"]
+
+Scope = MutableMapping[str, Any]
+Message = MutableMapping[str, Any]
+Receive = Callable[[], Awaitable[Message]]
+Send = Callable[[Message], Awaitable[None]]
+ASGIApp = Callable[[Scope, Receive, Send], Awaitable[None]]
+
+
+class LogSetuMiddleware:
+    """Pure ASGI middleware (no ``BaseHTTPMiddleware``), so it doesn't buffer streaming responses."""
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        *,
+        api_key: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        environment: Optional[str] = None,
+        source: Optional[str] = None,
+        get_tenant_id: Any = None,
+        capture_logging: bool = True,
+        log_level: int = logging.WARNING,
+        capture_5xx: bool = True,
+        log_requests: bool = False,
+        ignore_paths: Iterable[str] = (),
+        redact_headers: Iterable[str] = DEFAULT_REDACT_HEADERS,
+        debug: bool = False,
+        client: Optional[LogSetuClient] = None,
+    ) -> None:
+        self.app = app
+        self.environment = environment or os.environ.get("LOGSETU_ENVIRONMENT") or "production"
+        self.source = source or os.environ.get("LOGSETU_SOURCE") or "asgi"
+        self.client = make_client(
+            api_key or os.environ.get("LOGSETU_API_KEY"),
+            endpoint or os.environ.get("LOGSETU_ENDPOINT"),
+            environment=self.environment,
+            source=self.source,
+            debug=debug,
+            client=client,
+        )
+        if capture_logging:
+            attach_handler(self.client, log_level)
+        # Called with the ASGI scope; return a tenant id or None.
+        self.get_tenant_id: Optional[Callable[[Scope], Any]] = import_callable(get_tenant_id)
+        self.capture_5xx = capture_5xx
+        self.log_requests = log_requests
+        self.ignore_paths = frozenset(ignore_paths)
+        self.redact_headers = tuple(redact_headers)
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http" or scope.get("path") in self.ignore_paths:
+            await self.app(scope, receive, send)
+            return
+
+        headers = {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in scope.get("headers") or []}
+        ctx: Dict[str, Any] = {"request_id": request_id(headers), "method": scope.get("method"), "path": scope.get("path")}
+        client_addr = scope.get("client")
+        ip = client_ip(headers, client_addr[0] if client_addr else None)
+        if ip:
+            ctx["ip"] = ip
+        if self.get_tenant_id is not None:
+            try:
+                tenant = self.get_tenant_id(scope)
+                if tenant is not None:
+                    ctx["tenant_id"] = str(tenant)
+            except Exception:
+                pass
+        scope.setdefault("state", {})["logsetu_request_id"] = ctx["request_id"]
+
+        status = 0
+        started = time.monotonic()
+
+        async def send_wrapper(message: Message) -> None:
+            nonlocal status
+            if message["type"] == "http.response.start":
+                status = int(message["status"])
+            await send(message)
+
+        token = set_request_context(ctx)
+        try:
+            await self.app(scope, receive, send_wrapper)
+        except BaseException as exc:
+            if isinstance(exc, Exception):
+                self._report(scope, headers, "error", f"{type(exc).__name__}: {exc}",
+                             {**exception_meta(exc), "status": status or 500, "duration_ms": _ms(started)})
+                mark_reported(exc)
+            raise
+        else:
+            if self.capture_5xx and status >= 500:
+                self._report(scope, headers, "error", f"HTTP {status} on {scope.get('method')} {scope.get('path')}",
+                             {"status": status, "duration_ms": _ms(started)})
+            elif self.log_requests:
+                self._report(scope, headers, "warn" if status >= 400 else "info",
+                             f"{scope.get('method')} {scope.get('path')} {status}",
+                             {"status": status, "duration_ms": _ms(started)}, with_headers=False)
+        finally:
+            reset_request_context(token)
+
+    def _report(self, scope: Scope, headers: Dict[str, str], level: str, message: str, extra: Dict[str, Any],
+                *, with_headers: bool = True) -> None:
+        try:
+            info: Dict[str, Any] = {
+                "method": scope.get("method"),
+                "path": scope.get("path"),
+                "query": (scope.get("query_string") or b"").decode("latin-1")[:2000],
+            }
+            route = getattr(scope.get("route"), "path", None)
+            if route:
+                info["route"] = route
+            if with_headers:
+                info["headers"] = redact(headers.items(), self.redact_headers)
+            meta = {**get_request_context(), **extra, "request": info}
+            self.client.log(level, message, meta, source=self.source, environment=self.environment)
+        except Exception:  # never break the response cycle
+            pass
+
+
+def _ms(started: float) -> int:
+    return int((time.monotonic() - started) * 1000)

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.3.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-python/{__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/fastapi.py

@@ -0,0 +1,11 @@
+"""FastAPI integration — an alias of :mod:`logsetu.asgi`.
+
+::
+
+    from logsetu.fastapi import LogSetuMiddleware
+    app.add_middleware(LogSetuMiddleware, api_key=..., endpoint=..., source="fastapi")
+"""
+
+from .asgi import LogSetuMiddleware
+
+__all__ = ["LogSetuMiddleware"]

logsetu/flask.py

@@ -0,0 +1,141 @@
+"""Flask integration: request context on every log, unhandled exceptions and 5xx responses reported.
+
+::
+
+    from flask import Flask
+    from logsetu.flask import LogSetu
+
+    app = Flask(__name__)
+    LogSetu(app, api_key=os.environ["LOGSETU_API_KEY"], endpoint=os.environ["LOGSETU_ENDPOINT"], source="flask-api")
+
+or with an app factory: ``logsetu = LogSetu()`` at module level, then ``logsetu.init_app(app)``. Options not passed
+explicitly are read from ``app.config`` (``LOGSETU_API_KEY``, ``LOGSETU_ENDPOINT``, ``LOGSETU_ENVIRONMENT``,
+``LOGSETU_SOURCE``).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Iterable, Optional
+
+from flask import Flask, g, got_request_exception, request
+
+from .client import LogSetuClient
+from .conf import DEFAULT_REDACT_HEADERS, import_callable
+from .context import get_request_context, reset_request_context, set_request_context
+from .web import attach_handler, client_ip, exception_meta, make_client, mark_reported, redact, request_id
+
+__all__ = ["LogSetu"]
+
+
+class LogSetu:
+    """Flask extension. ``capture_logging`` also forwards stdlib ``logging`` records at ``log_level`` and above."""
+
+    def __init__(
+        self,
+        app: Optional[Flask] = None,
+        *,
+        api_key: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        environment: Optional[str] = None,
+        source: Optional[str] = None,
+        get_tenant_id: Any = None,
+        capture_logging: bool = True,
+        log_level: int = logging.WARNING,
+        capture_5xx: bool = True,
+        log_requests: bool = False,
+        redact_headers: Iterable[str] = DEFAULT_REDACT_HEADERS,
+        debug: bool = False,
+        client: Optional[LogSetuClient] = None,
+    ) -> None:
+        self._options = dict(api_key=api_key, endpoint=endpoint, environment=environment, source=source)
+        self.get_tenant_id: Optional[Callable[[Any], Any]] = import_callable(get_tenant_id)
+        self.capture_logging = capture_logging
+        self.log_level = log_level
+        self.capture_5xx = capture_5xx
+        self.log_requests = log_requests
+        self.redact_headers = tuple(redact_headers)
+        self.debug = debug
+        self.client: Optional[LogSetuClient] = client
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app: Flask) -> None:
+        cfg = app.config
+        self.environment = self._options["environment"] or cfg.get("LOGSETU_ENVIRONMENT") or cfg.get("ENV") or "production"
+        self.source = self._options["source"] or cfg.get("LOGSETU_SOURCE") or "flask"
+        self.client = make_client(
+            self._options["api_key"] or cfg.get("LOGSETU_API_KEY"),
+            self._options["endpoint"] or cfg.get("LOGSETU_ENDPOINT"),
+            environment=self.environment,
+            source=self.source,
+            debug=self.debug,
+            client=self.client,
+        )
+        if self.capture_logging:
+            attach_handler(self.client, self.log_level)
+
+        app.before_request(self._before_request)
+        app.after_request(self._after_request)
+        app.teardown_request(self._teardown_request)
+        got_request_exception.connect(self._on_exception, app, weak=False)
+        app.extensions["logsetu"] = self
+
+    # ---------- request lifecycle ----------
+
+    def _before_request(self) -> None:
+        headers = {k.lower(): v for k, v in request.headers.items()}
+        ctx = {"request_id": request_id(headers), "method": request.method, "path": request.path}
+        ip = client_ip(headers, request.remote_addr)
+        if ip:
+            ctx["ip"] = ip
+        if self.get_tenant_id is not None:
+            try:
+                tenant = self.get_tenant_id(request)
+                if tenant is not None:
+                    ctx["tenant_id"] = str(tenant)
+            except Exception:
+                pass
+        g._logsetu_token = set_request_context(ctx)
+        g.logsetu_request_id = ctx["request_id"]
+
+    def _after_request(self, response: Any) -> Any:
+        try:
+            status = response.status_code
+            if self.capture_5xx and status >= 500 and not g.get("_logsetu_reported"):
+                self._report("error", f"HTTP {status} on {request.method} {request.path}", {"status": status})
+            elif self.log_requests:
+                level = "warn" if status >= 400 else "info"
+                self._report(level, f"{request.method} {request.path} {status}", {"status": status}, with_headers=False)
+        except Exception:
+            pass
+        return response
+
+    def _teardown_request(self, _exc: Optional[BaseException]) -> None:
+        token = g.pop("_logsetu_token", None)
+        if token is not None:
+            reset_request_context(token)
+
+    def _on_exception(self, _sender: Any, exception: BaseException, **_: Any) -> None:
+        self._report("error", f"{type(exception).__name__}: {exception}", exception_meta(exception))
+        mark_reported(exception)
+        g._logsetu_reported = True
+
+    # ---------- helpers ----------
+
+    def _report(self, level: str, message: str, extra: dict, *, with_headers: bool = True) -> None:
+        if self.client is None:
+            return
+        try:
+            info = {"method": request.method, "path": request.path, "query": request.query_string.decode("latin-1")[:2000]}
+            endpoint = request.endpoint
+            if endpoint:
+                info["endpoint"] = endpoint
+            if request.url_rule is not None:
+                info["route"] = request.url_rule.rule
+            if with_headers:
+                info["headers"] = redact(request.headers.items(), self.redact_headers)
+            meta = {**get_request_context(), **extra, "request": info}
+            self.client.log(level, message, meta, source=self.source, environment=self.environment)
+        except Exception:  # never break the response cycle
+            pass