Skip to content

armgit / meet

Public Imported from GitHub
0

Open source video conferencing app powered by LiveKit. Built with Django and React.

3.9 KB
Raw Blame
"""Read the network fields and the request id behind an audit event."""

import uuid
from contextvars import ContextVar, Token
from dataclasses import dataclass
from typing import Any

from django.conf import settings

from dockerflow.logging import request_id_context
from rest_framework.throttling import BaseThrottle

USER_AGENT_MAX_LENGTH = 1024


def current_request_id() -> str | None:
    """Return the id of the request being served, if any."""
    return request_id_context.get(None)


def resolve_client_ip(request) -> str | None:
    """Return the address of the real client, never the one of a proxy.

    It reuses DRF's throttles to identify the client.
    """
    return BaseThrottle().get_ident(request) or request.META.get("REMOTE_ADDR")


@dataclass(frozen=True)
class RequestContext:
    """What an audit event reads from the request behind it.

    The network fields are read once, when the request comes in. The request
    itself is kept for the actor, only known once it is authenticated: it is
    the Django request, onto which DRF copies its user and auth, but not its
    authenticator, so the auth method of a DRF view is not known from it.
    Outside a request, every field is ``None``.
    """

    request: Any = None
    request_id: str | None = None
    method: str | None = None
    path: str | None = None
    client_ip: str | None = None
    user_agent: str | None = None

    @classmethod
    def from_request(cls, request) -> "RequestContext":
        """Read the context of ``request``, its user agent cut where ECS stops."""
        meta = getattr(request, "META", None) or {}
        return cls(
            request=request,
            request_id=current_request_id(),
            method=getattr(request, "method", None),
            path=getattr(request, "path", None) or None,
            client_ip=resolve_client_ip(request),
            user_agent=meta.get("HTTP_USER_AGENT", "")[:USER_AGENT_MAX_LENGTH] or None,
        )


_request_context: ContextVar[RequestContext | None] = ContextVar(
    "audit_request_context", default=None
)


def request_context() -> RequestContext:
    """Return the context of the request being served, as set by ``AuditLogMiddleware``.

    It is empty outside a request.
    """
    return _request_context.get() or RequestContext()


def set_request_context(context: RequestContext) -> Token:
    """Make ``context`` the one of the request being served, until reset."""
    return _request_context.set(context)


def reset_request_context(token: Token) -> None:
    """Restore the context that was current before ``set_request_context``."""
    _request_context.reset(token)


class AuditLogMiddleware:
    """Settle the request id and the request context, then echo the id.

    It must come right after ``DockerflowMiddleware``, which sets the id from
    the inbound ``DOCKERFLOW_REQUEST_ID_HEADER_NAME`` header. Unless
    ``REQUEST_ID_TRUST_HEADER`` says the ingress overwrites that header, the id
    is replaced by a fresh one before anything logs, so that a client, the web
    server access log and the audit events of a request can be joined on an id
    the client did not choose.

    The context of the request is kept while it is served, so that an audit
    event emitted far from the view, as from a service, still reads its actor
    and network fields from it.
    """

    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if not settings.REQUEST_ID_TRUST_HEADER:
            request_id_context.set(str(uuid.uuid4()))

        token = set_request_context(RequestContext.from_request(request))
        try:
            response = self.get_response(request)
        finally:
            reset_request_context(token)
        header = settings.DOCKERFLOW_REQUEST_ID_HEADER_NAME
        if not response.has_header(header):
            response[header] = current_request_id()
        return response