baltimore-patapsco 0.1.0__tar.gz

baltimore_patapsco-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.3
+Name: baltimore-patapsco
+Version: 0.1.0
+Summary: Shared Django runtime foundations for Baltimore civic applications
+Author: Mayor's Office of Performance and Innovation
+Requires-Dist: django>=6.0,<7.0
+Requires-Dist: djangorestframework>=3.16,<4.0
+Requires-Dist: drf-spectacular>=0.28,<0.30
+Requires-Dist: django-allauth[socialaccount]>=65.10,<66.0 ; extra == 'auth'
+Requires-Dist: django-auditlog>=3.3,<4.0 ; extra == 'auth'
+Requires-Dist: django-anymail[sendgrid]>=15.0,<16.0 ; extra == 'email'
+Requires-Dist: sentry-sdk[django]>=2.64.0,<3.0 ; extra == 'observability'
+Requires-Dist: dj-database-url>=3.0,<4.0 ; extra == 'runtime'
+Requires-Dist: django-cors-headers>=4.9,<5.0 ; extra == 'runtime'
+Requires-Dist: django-environ>=0.12,<0.14 ; extra == 'runtime'
+Requires-Dist: whitenoise>=6.9,<7.0 ; extra == 'runtime'
+Requires-Python: >=3.13
+Provides-Extra: auth
+Provides-Extra: email
+Provides-Extra: observability
+Provides-Extra: runtime
+Description-Content-Type: text/markdown
+
+# baltimore-patapsco (Python)
+
+Reusable Django runtime primitives for Baltimore civic applications.
+
+```python
+INSTALLED_APPS += ["baltimore.patapsco"]
+MIDDLEWARE += ["baltimore.patapsco.observability.RequestContextMiddleware"]
+
+REST_FRAMEWORK = {
+    "EXCEPTION_HANDLER": "baltimore.patapsco.api.exception_handler",
+}
+
+urlpatterns = [path("", include("baltimore.patapsco.urls"))]
+```
+
+Use `build_logging_config()` for the shared JSON/pretty log shape. Modules are
+incrementally adoptable; installing the package does not enable auth, email, or
+Sentry by itself.

baltimore_patapsco-0.1.0/README.md

@@ -0,0 +1,18 @@
+# baltimore-patapsco (Python)
+
+Reusable Django runtime primitives for Baltimore civic applications.
+
+```python
+INSTALLED_APPS += ["baltimore.patapsco"]
+MIDDLEWARE += ["baltimore.patapsco.observability.RequestContextMiddleware"]
+
+REST_FRAMEWORK = {
+    "EXCEPTION_HANDLER": "baltimore.patapsco.api.exception_handler",
+}
+
+urlpatterns = [path("", include("baltimore.patapsco.urls"))]
+```
+
+Use `build_logging_config()` for the shared JSON/pretty log shape. Modules are
+incrementally adoptable; installing the package does not enable auth, email, or
+Sentry by itself.

baltimore_patapsco-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "baltimore-patapsco"
+version = "0.1.0"
+description = "Shared Django runtime foundations for Baltimore civic applications"
+readme = "README.md"
+requires-python = ">=3.13"
+authors = [{ name = "Mayor's Office of Performance and Innovation" }]
+dependencies = [
+  "django>=6.0,<7.0",
+  "djangorestframework>=3.16,<4.0",
+  "drf-spectacular>=0.28,<0.30",
+]
+
+[project.optional-dependencies]
+runtime = [
+  "dj-database-url>=3.0,<4.0",
+  "django-cors-headers>=4.9,<5.0",
+  "django-environ>=0.12,<0.14",
+  "whitenoise>=6.9,<7.0",
+]
+observability = ["sentry-sdk[django]>=2.64.0,<3.0"]
+auth = [
+  "django-allauth[socialaccount]>=65.10,<66.0",
+  "django-auditlog>=3.3,<4.0",
+]
+email = ["django-anymail[sendgrid]>=15.0,<16.0"]
+
+[build-system]
+requires = ["uv_build>=0.11.28,<0.15"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "baltimore.patapsco"
+module-root = "src"

baltimore_patapsco-0.1.0/src/baltimore/patapsco/__init__.py

@@ -0,0 +1,7 @@
+"""Shared Django runtime foundations for Baltimore civic applications."""
+
+from baltimore.patapsco.contracts import REQUEST_ID_HEADER
+
+__all__ = ["REQUEST_ID_HEADER", "__version__"]
+
+__version__ = "0.1.0"

baltimore_patapsco-0.1.0/src/baltimore/patapsco/api/__init__.py

@@ -0,0 +1,7 @@
+from baltimore.patapsco.api.errors import (
+    api_error_response,
+    build_error_payload,
+    exception_handler,
+)
+
+__all__ = ["api_error_response", "build_error_payload", "exception_handler"]

baltimore_patapsco-0.1.0/src/baltimore/patapsco/api/errors.py

@@ -0,0 +1,115 @@
+import logging
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from baltimore.patapsco.contracts import (
+    REQUEST_ID_HEADER,
+    ErrorBody,
+    ErrorEnvelope,
+    error_code_for_status,
+)
+from baltimore.patapsco.observability import get_request_id, new_request_id
+from rest_framework.response import Response
+from rest_framework.views import exception_handler as drf_exception_handler
+
+logger = logging.getLogger("baltimore.patapsco.api")
+
+_INTERNAL_MESSAGE = "The request could not be completed."
+_VALIDATION_MESSAGE = "Review the submitted values and try again."
+
+
+def build_error_payload(
+    *,
+    code: str,
+    message: str,
+    request_id: str,
+    details: object | None = None,
+) -> ErrorEnvelope:
+    error: ErrorBody = {
+        "code": code,
+        "message": message,
+        "request_id": request_id,
+    }
+    if details is not None:
+        error["details"] = details
+    return {"error": error}
+
+
+def api_error_response(
+    *,
+    status_code: int,
+    code: str | None = None,
+    message: str,
+    request_id: str | None = None,
+    details: object | None = None,
+) -> Response:
+    resolved_request_id = request_id or get_request_id() or new_request_id()
+    response = Response(
+        build_error_payload(
+            code=code or error_code_for_status(status_code),
+            message=message,
+            request_id=resolved_request_id,
+            details=details,
+        ),
+        status=status_code,
+    )
+    response[REQUEST_ID_HEADER] = resolved_request_id
+    return response
+
+
+def _request_id_from_context(context: Mapping[str, Any]) -> str:
+    request = context.get("request")
+    value = getattr(request, "request_id", None)
+    return value if isinstance(value, str) and value else get_request_id() or new_request_id()
+
+
+def _public_error_parts(data: object, status_code: int) -> tuple[str, object | None]:
+    if status_code >= 500:
+        return _INTERNAL_MESSAGE, None
+
+    if isinstance(data, Mapping):
+        detail = data.get("detail")
+        if isinstance(detail, str) and detail.strip():
+            return detail, None
+        return _VALIDATION_MESSAGE, dict(data)
+
+    if isinstance(data, Sequence) and not isinstance(data, (str, bytes, bytearray)):
+        return _VALIDATION_MESSAGE, list(data)
+
+    if isinstance(data, str) and data.strip():
+        return data, None
+    return _INTERNAL_MESSAGE, None
+
+
+def exception_handler(exc: Exception, context: dict[str, Any]) -> Response:
+    request_id = _request_id_from_context(context)
+    response = drf_exception_handler(exc, context)
+    if response is None:
+        unhandled = True
+        response = Response(status=500)
+    else:
+        unhandled = False
+
+    status_code = response.status_code
+    message, details = _public_error_parts(response.data, status_code)
+    response.data = build_error_payload(
+        code=error_code_for_status(status_code),
+        message=message,
+        request_id=request_id,
+        details=details,
+    )
+    response[REQUEST_ID_HEADER] = request_id
+
+    request = context.get("request")
+    extra = {
+        "event": "api.error",
+        "request_id": request_id,
+        "method": getattr(request, "method", None),
+        "route": getattr(request, "path", None),
+        "status_code": status_code,
+    }
+    if unhandled:
+        logger.exception("api.unhandled_exception", exc_info=exc, extra=extra)
+    else:
+        logger.warning("api.request_error", extra=extra)
+    return response

baltimore_patapsco-0.1.0/src/baltimore/patapsco/api/serializers.py

@@ -0,0 +1,25 @@
+from rest_framework import serializers
+
+
+class HealthSerializer(serializers.Serializer[dict[str, object]]):
+    status = serializers.CharField()
+    version = serializers.CharField()
+    request_id = serializers.CharField()
+
+
+class DependencyCheckSerializer(serializers.Serializer[dict[str, object]]):
+    status = serializers.CharField()
+
+
+class ReadinessSerializer(HealthSerializer):
+    checks = serializers.DictField(child=DependencyCheckSerializer())
+
+
+class DiagnosticsSerializer(serializers.Serializer[dict[str, object]]):
+    status = serializers.CharField()
+    service = serializers.CharField()
+    environment = serializers.CharField()
+    release = serializers.CharField(allow_null=True)
+    platform_version = serializers.CharField()
+    django_version = serializers.CharField()
+    request_id = serializers.CharField()

baltimore_patapsco-0.1.0/src/baltimore/patapsco/api/views.py

@@ -0,0 +1,93 @@
+import logging
+import os
+
+import django
+from baltimore.patapsco import __version__
+from baltimore.patapsco.api.serializers import (
+    DiagnosticsSerializer,
+    HealthSerializer,
+    ReadinessSerializer,
+)
+from baltimore.patapsco.observability import get_request_id, new_request_id
+from django.conf import settings
+from django.db import connection
+from drf_spectacular.utils import extend_schema
+from rest_framework.permissions import AllowAny, IsAdminUser
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+logger = logging.getLogger("baltimore.patapsco.health")
+
+
+def _request_id(request: Request) -> str:
+    value = getattr(request, "request_id", None)
+    return value if isinstance(value, str) and value else get_request_id() or new_request_id()
+
+
+class HealthView(APIView):
+    authentication_classes: list[type] = []
+    permission_classes = [AllowAny]
+
+    @extend_schema(responses={200: HealthSerializer})
+    def get(self, request: Request) -> Response:
+        return Response(
+            {
+                "status": "ok",
+                "version": __version__,
+                "request_id": _request_id(request),
+            }
+        )
+
+
+class ReadinessView(APIView):
+    authentication_classes: list[type] = []
+    permission_classes = [AllowAny]
+
+    @extend_schema(responses={200: ReadinessSerializer, 503: ReadinessSerializer})
+    def get(self, request: Request) -> Response:
+        database_status = "ok"
+        status_code = 200
+        try:
+            with connection.cursor() as cursor:
+                cursor.execute("SELECT 1")
+                cursor.fetchone()
+        except Exception:
+            database_status = "unavailable"
+            status_code = 503
+            logger.exception(
+                "readiness.database_unavailable",
+                extra={"event": "readiness.database_unavailable"},
+            )
+
+        return Response(
+            {
+                "status": "ok" if status_code == 200 else "unavailable",
+                "version": __version__,
+                "request_id": _request_id(request),
+                "checks": {"database": {"status": database_status}},
+            },
+            status=status_code,
+        )
+
+
+class DiagnosticsView(APIView):
+    def get_permissions(self) -> list[AllowAny | IsAdminUser]:
+        permission_class = (
+            AllowAny if getattr(settings, "PATAPSCO_DIAGNOSTICS_PUBLIC", False) else IsAdminUser
+        )
+        return [permission_class()]
+
+    @extend_schema(responses={200: DiagnosticsSerializer})
+    def get(self, request: Request) -> Response:
+        return Response(
+            {
+                "status": "ok",
+                "service": getattr(settings, "PATAPSCO_SERVICE_NAME", "django-app"),
+                "environment": os.getenv("APP_ENV", "local"),
+                "release": os.getenv("APP_RELEASE") or None,
+                "platform_version": __version__,
+                "django_version": django.get_version(),
+                "request_id": _request_id(request),
+            }
+        )

baltimore_patapsco-0.1.0/src/baltimore/patapsco/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class BaltPlatformConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "baltimore.patapsco"
+    verbose_name = "Baltimore Platform"

baltimore_patapsco-0.1.0/src/baltimore/patapsco/contracts.py

@@ -0,0 +1,32 @@
+from typing import NotRequired, TypedDict
+
+REQUEST_ID_HEADER = "X-Request-ID"
+CLIENT_SURFACE_HEADER = "X-Client-Surface"
+UPLOAD_ATTEMPT_ID_HEADER = "X-Upload-Attempt-ID"
+
+
+class ErrorBody(TypedDict):
+    code: str
+    message: str
+    request_id: str
+    details: NotRequired[object]
+
+
+class ErrorEnvelope(TypedDict):
+    error: ErrorBody
+
+
+STATUS_ERROR_CODES: dict[int, str] = {
+    400: "validation_error",
+    401: "unauthorized",
+    403: "forbidden",
+    404: "not_found",
+    409: "conflict",
+    429: "throttled",
+}
+
+
+def error_code_for_status(status_code: int) -> str:
+    if status_code >= 500:
+        return "internal_error"
+    return STATUS_ERROR_CODES.get(status_code, "request_error")

baltimore_patapsco-0.1.0/src/baltimore/patapsco/observability/__init__.py

@@ -0,0 +1,33 @@
+from baltimore.patapsco.observability.context import (
+    bind_log_context,
+    get_log_context,
+    get_request_id,
+    new_request_id,
+    normalize_request_id,
+    request_context,
+)
+from baltimore.patapsco.observability.logging import (
+    JsonFormatter,
+    PrettyFormatter,
+    RequestContextFilter,
+    build_logging_config,
+    resolve_log_format,
+)
+from baltimore.patapsco.observability.middleware import RequestContextMiddleware
+from baltimore.patapsco.observability.sentry import configure_sentry
+
+__all__ = [
+    "JsonFormatter",
+    "PrettyFormatter",
+    "RequestContextFilter",
+    "RequestContextMiddleware",
+    "bind_log_context",
+    "build_logging_config",
+    "configure_sentry",
+    "get_log_context",
+    "get_request_id",
+    "new_request_id",
+    "normalize_request_id",
+    "request_context",
+    "resolve_log_format",
+]

baltimore_patapsco-0.1.0/src/baltimore/patapsco/observability/context.py

@@ -0,0 +1,50 @@
+import re
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from contextvars import ContextVar
+from uuid import uuid4
+
+_REQUEST_ID_PATTERN = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
+_request_id: ContextVar[str | None] = ContextVar("baltimore_patapsco_request_id", default=None)
+_log_context: ContextVar[dict[str, object] | None] = ContextVar(
+    "baltimore_patapsco_log_context", default=None
+)
+
+
+def normalize_request_id(value: str | None) -> str | None:
+    if value is None:
+        return None
+    candidate = value.strip()
+    return candidate if _REQUEST_ID_PATTERN.fullmatch(candidate) else None
+
+
+def new_request_id() -> str:
+    return str(uuid4())
+
+
+def get_request_id() -> str | None:
+    return _request_id.get()
+
+
+def get_log_context() -> dict[str, object]:
+    return dict(_log_context.get() or {})
+
+
+def bind_log_context(**values: object) -> None:
+    context = get_log_context()
+    context.update({key: value for key, value in values.items() if value is not None})
+    _log_context.set(context)
+
+
+@contextmanager
+def request_context(
+    request_id: str,
+    values: Mapping[str, object] | None = None,
+) -> Iterator[None]:
+    request_token = _request_id.set(request_id)
+    context_token = _log_context.set(dict(values or {}))
+    try:
+        yield
+    finally:
+        _log_context.reset(context_token)
+        _request_id.reset(request_token)

baltimore_patapsco-0.1.0/src/baltimore/patapsco/observability/logging.py

@@ -0,0 +1,142 @@
+import json
+import logging
+import os
+from collections.abc import Mapping
+from datetime import UTC, datetime
+from typing import Any
+
+from baltimore.patapsco.observability.context import get_log_context, get_request_id
+
+_CONTEXT_FIELDS = (
+    "event",
+    "request_id",
+    "method",
+    "route",
+    "status_code",
+    "latency_ms",
+    "user_id",
+    "client_surface",
+    "upload_attempt_id",
+)
+_LOG_RECORD_FIELDS = frozenset(logging.makeLogRecord({}).__dict__)
+_SENSITIVE_KEY_PARTS = ("authorization", "cookie", "password", "secret", "token", "api_key")
+
+
+def _safe_custom_context(record: logging.LogRecord) -> dict[str, object]:
+    context: dict[str, object] = {}
+    for key, value in record.__dict__.items():
+        if (
+            key in _LOG_RECORD_FIELDS
+            or key in _CONTEXT_FIELDS
+            or key == "context"
+            or key.startswith("_")
+        ):
+            continue
+        normalized_key = key.lower()
+        context[key] = (
+            "[REDACTED]" if any(part in normalized_key for part in _SENSITIVE_KEY_PARTS) else value
+        )
+    explicit_context = getattr(record, "context", None)
+    if isinstance(explicit_context, Mapping):
+        for key, value in explicit_context.items():
+            normalized_key = str(key).lower()
+            context[str(key)] = (
+                "[REDACTED]"
+                if any(part in normalized_key for part in _SENSITIVE_KEY_PARTS)
+                else value
+            )
+    return context
+
+
+class RequestContextFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        context = get_log_context()
+        context.setdefault("request_id", get_request_id())
+        for key, value in context.items():
+            if value is not None and not hasattr(record, key):
+                setattr(record, key, value)
+        return True
+
+
+class JsonFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        payload: dict[str, object] = {
+            "timestamp": datetime.fromtimestamp(record.created, tz=UTC).isoformat(
+                timespec="milliseconds"
+            ),
+            "level": record.levelname.lower(),
+            "logger": record.name,
+            "message": record.getMessage(),
+        }
+        for field in _CONTEXT_FIELDS:
+            value = getattr(record, field, None)
+            if value is not None:
+                payload[field] = value
+        custom_context = _safe_custom_context(record)
+        if custom_context:
+            payload["context"] = custom_context
+        if record.exc_info:
+            payload["exception"] = self.formatException(record.exc_info)
+        if record.stack_info:
+            payload["stack"] = self.formatStack(record.stack_info)
+        return json.dumps(payload, ensure_ascii=True, separators=(",", ":"), default=str)
+
+
+class PrettyFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        timestamp = datetime.fromtimestamp(record.created, tz=UTC).strftime("%H:%M:%S")
+        request_id = getattr(record, "request_id", None)
+        context_parts = [f"request_id={request_id}"] if request_id else []
+        for field in ("method", "route", "status_code", "latency_ms"):
+            value = getattr(record, field, None)
+            if value is not None:
+                context_parts.append(f"{field}={value}")
+        request_suffix = f" {' '.join(context_parts)}" if context_parts else ""
+        rendered = (
+            f"{timestamp} {record.levelname:<8} {record.name}{request_suffix} {record.getMessage()}"
+        )
+        if record.exc_info:
+            rendered = f"{rendered}\n{self.formatException(record.exc_info)}"
+        return rendered
+
+
+def resolve_log_format(value: str | None = None) -> str:
+    resolved = (value or os.getenv("APP_LOG_FORMAT") or "json").strip().lower()
+    if resolved not in {"json", "pretty"}:
+        raise ValueError("APP_LOG_FORMAT must be 'json' or 'pretty'")
+    return resolved
+
+
+def build_logging_config(
+    *, log_format: str | None = None, level: str | None = None
+) -> dict[str, Any]:
+    formatter_name = resolve_log_format(log_format)
+    log_level = (level or os.getenv("APP_LOG_LEVEL") or "INFO").strip().upper()
+    return {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "filters": {
+            "request_context": {
+                "()": "baltimore.patapsco.observability.logging.RequestContextFilter"
+            }
+        },
+        "formatters": {
+            "json": {"()": "baltimore.patapsco.observability.logging.JsonFormatter"},
+            "pretty": {"()": "baltimore.patapsco.observability.logging.PrettyFormatter"},
+        },
+        "handlers": {
+            "console": {
+                "class": "logging.StreamHandler",
+                "filters": ["request_context"],
+                "formatter": formatter_name,
+            }
+        },
+        "root": {"handlers": ["console"], "level": log_level},
+        "loggers": {
+            "django.server": {
+                "handlers": ["console"],
+                "level": log_level,
+                "propagate": False,
+            }
+        },
+    }

baltimore_patapsco-0.1.0/src/baltimore/patapsco/observability/middleware.py

@@ -0,0 +1,97 @@
+import logging
+from collections.abc import Awaitable, Callable
+from contextlib import AbstractContextManager
+from time import perf_counter
+from typing import cast
+
+from asgiref.sync import iscoroutinefunction, markcoroutinefunction
+from baltimore.patapsco.contracts import CLIENT_SURFACE_HEADER, REQUEST_ID_HEADER
+from baltimore.patapsco.observability.context import (
+    bind_log_context,
+    new_request_id,
+    normalize_request_id,
+    request_context,
+)
+from django.http import HttpRequest, HttpResponse
+
+logger = logging.getLogger("baltimore.patapsco.request")
+
+SyncResponse = Callable[[HttpRequest], HttpResponse]
+AsyncResponse = Callable[[HttpRequest], Awaitable[HttpResponse]]
+
+
+class RequestContextMiddleware:
+    sync_capable = True
+    async_capable = True
+
+    def __init__(self, get_response: SyncResponse | AsyncResponse) -> None:
+        self.get_response = get_response
+        self.is_async = iscoroutinefunction(get_response)
+        if self.is_async:
+            markcoroutinefunction(self)
+
+    def __call__(self, request: HttpRequest) -> HttpResponse | Awaitable[HttpResponse]:
+        if self.is_async:
+            return self.__acall__(request)
+        return self._handle_sync(request)
+
+    def _begin(self, request: HttpRequest) -> tuple[str, float, AbstractContextManager[None]]:
+        request_id = (
+            normalize_request_id(request.headers.get(REQUEST_ID_HEADER)) or new_request_id()
+        )
+        request.request_id = request_id  # type: ignore[attr-defined]
+        values: dict[str, object] = {
+            "method": request.method,
+            "route": request.path,
+        }
+        client_surface = request.headers.get(CLIENT_SURFACE_HEADER)
+        if client_surface:
+            values["client_surface"] = client_surface[:128]
+        return request_id, perf_counter(), request_context(request_id, values)
+
+    def _finish(
+        self,
+        request: HttpRequest,
+        response: HttpResponse,
+        request_id: str,
+        started_at: float,
+    ) -> HttpResponse:
+        latency_ms = round((perf_counter() - started_at) * 1000, 2)
+        user = getattr(request, "user", None)
+        user_id = getattr(user, "pk", None) if getattr(user, "is_authenticated", False) else None
+        bind_log_context(
+            event="request.complete",
+            status_code=response.status_code,
+            latency_ms=latency_ms,
+            user_id=user_id,
+        )
+        response[REQUEST_ID_HEADER] = request_id
+        logger.info("request.complete")
+        return response
+
+    def _log_exception(self, started_at: float) -> None:
+        bind_log_context(
+            event="request.exception",
+            latency_ms=round((perf_counter() - started_at) * 1000, 2),
+        )
+        logger.exception("request.exception")
+
+    def _handle_sync(self, request: HttpRequest) -> HttpResponse:
+        request_id, started_at, context = self._begin(request)
+        with context:
+            try:
+                response = cast(SyncResponse, self.get_response)(request)
+            except Exception:
+                self._log_exception(started_at)
+                raise
+            return self._finish(request, response, request_id, started_at)
+
+    async def __acall__(self, request: HttpRequest) -> HttpResponse:
+        request_id, started_at, context = self._begin(request)
+        with context:
+            try:
+                response = await cast(AsyncResponse, self.get_response)(request)
+            except Exception:
+                self._log_exception(started_at)
+                raise
+            return self._finish(request, response, request_id, started_at)

baltimore_patapsco-0.1.0/src/baltimore/patapsco/observability/sentry.py

@@ -0,0 +1,39 @@
+import logging
+import os
+from typing import Any
+
+
+def configure_sentry(
+    *,
+    dsn: str | None = None,
+    environment: str | None = None,
+    release: str | None = None,
+    traces_sample_rate: float | None = None,
+    profiles_sample_rate: float | None = None,
+) -> bool:
+    resolved_dsn = dsn if dsn is not None else os.getenv("SENTRY_DSN", "")
+    if not resolved_dsn:
+        return False
+
+    try:
+        import sentry_sdk
+        from sentry_sdk.integrations.django import DjangoIntegration
+        from sentry_sdk.integrations.logging import LoggingIntegration
+    except ImportError as exc:
+        raise RuntimeError(
+            "Install baltimore-patapsco[observability] before configuring Sentry"
+        ) from exc
+
+    options: dict[str, Any] = {
+        "dsn": resolved_dsn,
+        "environment": environment or os.getenv("APP_ENV", "local"),
+        "release": release or os.getenv("APP_RELEASE") or None,
+        "send_default_pii": False,
+        "integrations": [DjangoIntegration(), LoggingIntegration(event_level=logging.ERROR)],
+    }
+    if traces_sample_rate is not None:
+        options["traces_sample_rate"] = traces_sample_rate
+    if profiles_sample_rate is not None:
+        options["profiles_sample_rate"] = profiles_sample_rate
+    sentry_sdk.init(**options)
+    return True

baltimore_patapsco-0.1.0/src/baltimore/patapsco/urls.py

@@ -0,0 +1,10 @@
+from baltimore.patapsco.api.views import DiagnosticsView, HealthView, ReadinessView
+from django.urls import path
+
+app_name = "baltimore.patapsco"
+
+urlpatterns = [
+    path("healthz", HealthView.as_view(), name="health"),
+    path("readyz", ReadinessView.as_view(), name="readiness"),
+    path("api/diagnostics", DiagnosticsView.as_view(), name="diagnostics"),
+]