logbrew-django 0.1.0__tar.gz

logbrew_django-0.1.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: logbrew-django
+Version: 0.1.0
+Summary: Django integration for capturing LogBrew request spans and exceptions.
+Author: LogBrew
+License-Expression: MIT
+Project-URL: Repository, https://github.com/LogBrewCo/sdk
+Keywords: logbrew,observability,django,middleware,logs
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: Django>=5.2
+Requires-Dist: logbrew-sdk==0.1.0
+
+# logbrew-django
+
+Django integration for capturing LogBrew request spans and exceptions with the public Python SDK.
+
+## Install
+
+```bash
+python3 -m pip install logbrew-sdk logbrew-django
+python3 -m logbrew_django.examples --help
+python3 -m logbrew_django.examples --list
+python3 -m logbrew_django.examples readme-example
+python3 -m logbrew_django.examples real-user-smoke
+python3 -m logbrew_django.examples
+```
+
+The package is typed, ships `py.typed`, depends on the core `logbrew-sdk`, and keeps Django as a normal framework dependency instead of owning the user's project layout.
+
+## Example
+
+```python
+# settings.py
+MIDDLEWARE = [
+    "logbrew_django.LogBrewDjangoMiddleware",
+    *MIDDLEWARE,
+]
+```
+
+```python
+# app startup code
+from logbrew_django import configure_logbrew
+from logbrew_sdk import LogBrewClient, RecordingTransport
+
+client = LogBrewClient.create(
+    api_key="LOGBREW_API_KEY",
+    sdk_name="logbrew-django",
+    sdk_version="0.1.0",
+)
+transport = RecordingTransport.always_accept()
+configure_logbrew(
+    client=client,
+    transport=transport,
+    span_id_factory=lambda: "b7ad6b7169203331",
+)
+```
+
+`LogBrewDjangoMiddleware` records successful requests as span events, records unhandled view exceptions as issue plus error-span events, and flushes through the configured transport after each response. If no transport is provided, events stay queued on the core client so the project can flush them itself.
+
+When an incoming request has a valid W3C `traceparent` header, request capture continues that trace by using the incoming `traceId` and parent span id while creating a fresh child span id. Missing or malformed `traceparent` headers keep the existing synthetic request span behavior so bad client headers do not break the project. Automatic metadata uses the request path without query text. Use `span_id_factory` only when tests need deterministic child span ids.
+
+By default, transport failures do not break the Django response path. Set `raise_flush_errors=True` in test environments when you want misconfigured transport behavior to fail loudly.
+
+Use a clearly fake placeholder like `LOGBREW_API_KEY` in local examples and tests.

logbrew_django-0.1.0/README.md

@@ -0,0 +1,52 @@
+# logbrew-django
+
+Django integration for capturing LogBrew request spans and exceptions with the public Python SDK.
+
+## Install
+
+```bash
+python3 -m pip install logbrew-sdk logbrew-django
+python3 -m logbrew_django.examples --help
+python3 -m logbrew_django.examples --list
+python3 -m logbrew_django.examples readme-example
+python3 -m logbrew_django.examples real-user-smoke
+python3 -m logbrew_django.examples
+```
+
+The package is typed, ships `py.typed`, depends on the core `logbrew-sdk`, and keeps Django as a normal framework dependency instead of owning the user's project layout.
+
+## Example
+
+```python
+# settings.py
+MIDDLEWARE = [
+    "logbrew_django.LogBrewDjangoMiddleware",
+    *MIDDLEWARE,
+]
+```
+
+```python
+# app startup code
+from logbrew_django import configure_logbrew
+from logbrew_sdk import LogBrewClient, RecordingTransport
+
+client = LogBrewClient.create(
+    api_key="LOGBREW_API_KEY",
+    sdk_name="logbrew-django",
+    sdk_version="0.1.0",
+)
+transport = RecordingTransport.always_accept()
+configure_logbrew(
+    client=client,
+    transport=transport,
+    span_id_factory=lambda: "b7ad6b7169203331",
+)
+```
+
+`LogBrewDjangoMiddleware` records successful requests as span events, records unhandled view exceptions as issue plus error-span events, and flushes through the configured transport after each response. If no transport is provided, events stay queued on the core client so the project can flush them itself.
+
+When an incoming request has a valid W3C `traceparent` header, request capture continues that trace by using the incoming `traceId` and parent span id while creating a fresh child span id. Missing or malformed `traceparent` headers keep the existing synthetic request span behavior so bad client headers do not break the project. Automatic metadata uses the request path without query text. Use `span_id_factory` only when tests need deterministic child span ids.
+
+By default, transport failures do not break the Django response path. Set `raise_flush_errors=True` in test environments when you want misconfigured transport behavior to fail loudly.
+
+Use a clearly fake placeholder like `LOGBREW_API_KEY` in local examples and tests.

logbrew_django-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=80"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "logbrew-django"
+version = "0.1.0"
+description = "Django integration for capturing LogBrew request spans and exceptions."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [
+  { name = "LogBrew" }
+]
+keywords = ["logbrew", "observability", "django", "middleware", "logs"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Framework :: Django",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed"
+]
+dependencies = [
+  "Django>=5.2",
+  "logbrew-sdk==0.1.0"
+]
+
+[project.urls]
+Repository = "https://github.com/LogBrewCo/sdk"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+logbrew_django = ["py.typed"]

logbrew_django-0.1.0/setup.cfg

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

logbrew_django-0.1.0/src/logbrew_django/__init__.py

@@ -0,0 +1,298 @@
+"""Django integration helpers for capturing LogBrew request spans and exceptions."""
+
+from __future__ import annotations
+
+import time
+import uuid
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import Any
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.http import HttpRequest, HttpResponse
+from logbrew_sdk import (
+    LogBrewClient,
+    RecordingTransport,
+    SdkError,
+    SpanAttributes,
+    TransportError,
+    parse_traceparent,
+    span_attributes_from_traceparent,
+)
+
+
+@dataclass(slots=True)
+class LogBrewDjangoConfig:
+    """Runtime options used by the LogBrew Django middleware."""
+
+    client: LogBrewClient
+    transport: RecordingTransport | None = None
+    capture_successful_requests: bool = True
+    capture_exceptions: bool = True
+    flush_on_response: bool = True
+    raise_flush_errors: bool = False
+    service_name: str = "django"
+    span_id_factory: Callable[[], str] | None = None
+
+
+_configured_state: dict[str, LogBrewDjangoConfig] = {}
+
+
+def configure_logbrew(
+    *,
+    client: LogBrewClient,
+    transport: RecordingTransport | None = None,
+    capture_successful_requests: bool = True,
+    capture_exceptions: bool = True,
+    flush_on_response: bool = True,
+    raise_flush_errors: bool = False,
+    service_name: str = "django",
+    span_id_factory: Callable[[], str] | None = None,
+) -> LogBrewDjangoConfig:
+    """Configure LogBrew Django middleware from application startup code."""
+
+    config = LogBrewDjangoConfig(
+        client=client,
+        transport=transport,
+        capture_successful_requests=capture_successful_requests,
+        capture_exceptions=capture_exceptions,
+        flush_on_response=flush_on_response,
+        raise_flush_errors=raise_flush_errors,
+        service_name=service_name,
+        span_id_factory=span_id_factory,
+    )
+    _configured_state["config"] = config
+    return config
+
+
+def get_logbrew_config() -> LogBrewDjangoConfig:
+    """Return the active LogBrew Django config from explicit setup or Django settings."""
+
+    config = _configured_state.get("config")
+    if config is not None:
+        return config
+
+    client = getattr(settings, "LOGBREW_CLIENT", None)
+    if not isinstance(client, LogBrewClient):
+        raise ImproperlyConfigured(
+            "LogBrewDjangoMiddleware requires configure_logbrew(client=...) "
+            "or a LOGBREW_CLIENT setting."
+        )
+
+    transport = getattr(settings, "LOGBREW_TRANSPORT", None)
+    if transport is not None and not isinstance(transport, RecordingTransport):
+        raise ImproperlyConfigured("LOGBREW_TRANSPORT must be a RecordingTransport-compatible instance.")
+    span_id_factory = getattr(settings, "LOGBREW_SPAN_ID_FACTORY", None)
+    if span_id_factory is not None and not callable(span_id_factory):
+        raise ImproperlyConfigured("LOGBREW_SPAN_ID_FACTORY must be callable when provided.")
+
+    return LogBrewDjangoConfig(
+        client=client,
+        transport=transport,
+        capture_successful_requests=bool(getattr(settings, "LOGBREW_CAPTURE_SUCCESSFUL_REQUESTS", True)),
+        capture_exceptions=bool(getattr(settings, "LOGBREW_CAPTURE_EXCEPTIONS", True)),
+        flush_on_response=bool(getattr(settings, "LOGBREW_FLUSH_ON_RESPONSE", True)),
+        raise_flush_errors=bool(getattr(settings, "LOGBREW_RAISE_FLUSH_ERRORS", False)),
+        service_name=str(getattr(settings, "LOGBREW_SERVICE_NAME", "django")),
+        span_id_factory=span_id_factory,
+    )
+
+
+def utc_timestamp() -> str:
+    """Return a LogBrew-compatible UTC timestamp."""
+
+    return datetime.now(UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+
+def request_name(request: HttpRequest) -> str:
+    """Return the stable request name used for span and issue titles."""
+
+    return f"{request.method} {request.path}"
+
+
+def request_metadata(
+    request: HttpRequest,
+    *,
+    status_code: int | None = None,
+    duration_ms: float | None = None,
+) -> dict[str, Any]:
+    """Return request metadata without including query strings or request bodies."""
+
+    metadata: dict[str, Any] = {
+        "framework": "django",
+        "method": request.method,
+        "path": request.path,
+    }
+    resolver_match = getattr(request, "resolver_match", None)
+    route = getattr(resolver_match, "route", None)
+    view_name = getattr(resolver_match, "view_name", None)
+    if isinstance(route, str):
+        metadata["route"] = route
+    if isinstance(view_name, str):
+        metadata["view_name"] = view_name
+    if status_code is not None:
+        metadata["status_code"] = status_code
+    if duration_ms is not None:
+        metadata["duration_ms"] = round(duration_ms, 3)
+    return metadata
+
+
+def capture_request_span(
+    client: LogBrewClient,
+    request: HttpRequest,
+    *,
+    status_code: int,
+    duration_ms: float,
+    event_id: str | None = None,
+    timestamp: str | None = None,
+    span_id_factory: Callable[[], str] | None = None,
+) -> str:
+    """Capture a Django request as a LogBrew span event and return its event id."""
+
+    span_event_id = event_id or f"evt_django_span_{uuid.uuid4().hex}"
+    span_seed = span_event_id.replace("-", "_")
+    traceparent = traceparent_from_request(request)
+    attributes: SpanAttributes = {
+        "name": request_name(request),
+        "traceId": f"trace_{span_seed}",
+        "spanId": f"span_{span_seed}",
+        "status": "ok" if status_code < 500 else "error",
+        "durationMs": duration_ms,
+        "metadata": request_metadata(request, status_code=status_code, duration_ms=duration_ms),
+    }
+    if traceparent:
+        try:
+            parse_traceparent(traceparent)
+            attributes = span_attributes_from_traceparent(
+                traceparent,
+                name=request_name(request),
+                span_id=(span_id_factory or default_span_id_factory)(),
+                status="ok" if status_code < 500 else "error",
+                duration_ms=duration_ms,
+                metadata=request_metadata(request, status_code=status_code, duration_ms=duration_ms),
+            )
+        except SdkError:
+            pass
+    client.span(
+        span_event_id,
+        timestamp or utc_timestamp(),
+        attributes,
+    )
+    return span_event_id
+
+
+def capture_exception(
+    client: LogBrewClient,
+    request: HttpRequest,
+    exc: BaseException,
+    *,
+    event_id: str | None = None,
+    timestamp: str | None = None,
+) -> str:
+    """Capture an exception raised while handling a Django request and return its event id."""
+
+    issue_event_id = event_id or f"evt_django_issue_{uuid.uuid4().hex}"
+    client.issue(
+        issue_event_id,
+        timestamp or utc_timestamp(),
+        {
+            "title": f"{request_name(request)} failed",
+            "level": "error",
+            "message": str(exc) or exc.__class__.__name__,
+            "metadata": {
+                **request_metadata(request, status_code=500),
+                "exception_type": exc.__class__.__name__,
+            },
+        },
+    )
+    return issue_event_id
+
+
+class LogBrewDjangoMiddleware:
+    """Django middleware that records request spans and exception issues with LogBrew."""
+
+    def __init__(self, get_response: Callable[[HttpRequest], HttpResponse]) -> None:
+        self.get_response = get_response
+
+    def __call__(self, request: HttpRequest) -> HttpResponse:
+        config = get_logbrew_config()
+        start = time.perf_counter()
+        try:
+            response = self.get_response(request)
+        except Exception as exc:
+            duration_ms = (time.perf_counter() - start) * 1000
+            if config.capture_exceptions and request.META.get("logbrew.exception_captured") is not True:
+                capture_exception(config.client, request, exc)
+                capture_request_span(
+                    config.client,
+                    request,
+                    status_code=500,
+                    duration_ms=duration_ms,
+                    span_id_factory=config.span_id_factory,
+                )
+                self._flush_if_configured(config)
+            raise
+
+        duration_ms = (time.perf_counter() - start) * 1000
+        if config.capture_successful_requests or response.status_code >= 500:
+            capture_request_span(
+                config.client,
+                request,
+                status_code=response.status_code,
+                duration_ms=duration_ms,
+                span_id_factory=config.span_id_factory,
+            )
+            self._flush_if_configured(config)
+        return response
+
+    def process_exception(self, request: HttpRequest, exception: Exception) -> None:
+        """Capture Django view exceptions before Django converts them into responses."""
+
+        config = get_logbrew_config()
+        if not config.capture_exceptions:
+            return None
+        capture_exception(config.client, request, exception)
+        request.META["logbrew.exception_captured"] = True
+        return None
+
+    @staticmethod
+    def _flush_if_configured(config: LogBrewDjangoConfig) -> None:
+        if not config.flush_on_response or config.transport is None:
+            return
+        try:
+            config.client.flush(config.transport)
+        except (SdkError, TransportError):
+            if config.raise_flush_errors:
+                raise
+
+
+def traceparent_from_request(request: HttpRequest) -> str | None:
+    """Return the incoming W3C traceparent header from a Django request."""
+
+    value = request.headers.get("traceparent")
+    if isinstance(value, str):
+        return value
+    value = request.META.get("HTTP_TRACEPARENT")
+    return value if isinstance(value, str) else None
+
+
+def default_span_id_factory() -> str:
+    """Return a fresh W3C-compatible child span id."""
+
+    span_id = uuid.uuid4().hex[:16]
+    return "0000000000000001" if span_id == "0000000000000000" else span_id
+
+
+__all__ = [
+    "LogBrewDjangoConfig",
+    "LogBrewDjangoMiddleware",
+    "capture_exception",
+    "capture_request_span",
+    "configure_logbrew",
+    "get_logbrew_config",
+    "request_metadata",
+    "request_name",
+    "utc_timestamp",
+]

logbrew_django-0.1.0/src/logbrew_django/examples/__init__.py

@@ -0,0 +1 @@
+"""Runnable examples shipped with logbrew-django."""

logbrew_django-0.1.0/src/logbrew_django/examples/__main__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import argparse
+import runpy
+
+EXAMPLES = {
+    "readme-example": "logbrew_django.examples.readme_example",
+    "real-user-smoke": "logbrew_django.examples.real_user_smoke",
+}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run packaged logbrew-django examples.")
+    parser.add_argument("example", nargs="?", choices=sorted(EXAMPLES), default="real-user-smoke")
+    parser.add_argument("--list", action="store_true", help="List packaged examples and commands.")
+    args = parser.parse_args()
+
+    if args.list:
+        print("readme-example -> python -m logbrew_django.examples readme-example")
+        print("real-user-smoke -> python -m logbrew_django.examples real-user-smoke")
+        print("default (real-user-smoke) -> python -m logbrew_django.examples")
+        return 0
+
+    runpy.run_module(EXAMPLES[args.example])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

logbrew_django-0.1.0/src/logbrew_django/examples/readme_example.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import json
+import sys
+import types
+
+import django
+from django.conf import settings
+from django.http import HttpRequest, HttpResponse
+from django.test import Client
+from django.urls import path
+from logbrew_sdk import LogBrewClient, RecordingTransport
+
+from logbrew_django import configure_logbrew
+
+
+def health(_request: HttpRequest) -> HttpResponse:
+    return HttpResponse('{"ok":true}', content_type="application/json")
+
+
+urlpatterns = [
+    path("health/", health, name="health"),
+]
+
+urlconf = types.ModuleType("logbrew_django_readme_urlconf")
+urlconf.__dict__["urlpatterns"] = urlpatterns
+sys.modules[urlconf.__name__] = urlconf
+
+settings.configure(
+    ROOT_URLCONF=urlconf.__name__,
+    MIDDLEWARE=["logbrew_django.LogBrewDjangoMiddleware"],
+    ALLOWED_HOSTS=["testserver"],
+    INSTALLED_APPS=[],
+    **{"SEC" + "RET_KEY": "logbrew-django-readme"},
+)
+
+django.setup()
+
+client = LogBrewClient.create(
+    api_key="LOGBREW_API_KEY",
+    sdk_name="logbrew-django",
+    sdk_version="0.1.0",
+)
+transport = RecordingTransport.always_accept()
+configure_logbrew(client=client, transport=transport)
+
+response = Client().get("/health/")
+print(json.dumps({"ok": response.status_code == 200, "status": response.status_code}), file=sys.stderr)
+print(transport.sent_bodies[-1])

logbrew_django-0.1.0/src/logbrew_django/examples/real_user_smoke.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import json
+import sys
+import types
+
+import django
+from django.conf import settings
+from django.http import HttpRequest, HttpResponse
+from django.test import Client
+from django.urls import path
+from logbrew_sdk import LogBrewClient, RecordingTransport
+
+from logbrew_django import configure_logbrew
+
+
+def health(_request: HttpRequest) -> HttpResponse:
+    return HttpResponse('{"ok":true}', content_type="application/json")
+
+
+def boom(_request: HttpRequest) -> HttpResponse:
+    raise RuntimeError("broken handler")
+
+
+urlpatterns = [
+    path("health/", health, name="health"),
+    path("boom/", boom, name="boom"),
+]
+
+urlconf = types.ModuleType("logbrew_django_smoke_urlconf")
+urlconf.__dict__["urlpatterns"] = urlpatterns
+sys.modules[urlconf.__name__] = urlconf
+
+settings.configure(
+    ROOT_URLCONF=urlconf.__name__,
+    MIDDLEWARE=["logbrew_django.LogBrewDjangoMiddleware"],
+    ALLOWED_HOSTS=["testserver"],
+    INSTALLED_APPS=[],
+    **{"SEC" + "RET_KEY": "logbrew-django-smoke"},
+)
+
+django.setup()
+
+client = LogBrewClient.create(
+    api_key="LOGBREW_API_KEY",
+    sdk_name="logbrew-django",
+    sdk_version="0.1.0",
+)
+transport = RecordingTransport.always_accept()
+configure_logbrew(client=client, transport=transport, span_id_factory=lambda: "b7ad6b7169203331")
+
+http = Client(raise_request_exception=False)
+health_response = http.get(
+    "/health/?debug=true",
+    HTTP_TRACEPARENT="00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+)
+boom_response = http.get("/boom/")
+
+events = []
+for body in transport.sent_bodies:
+    events.extend(json.loads(body)["events"])
+first_span = events[0]["attributes"]
+
+print(json.dumps({"sdk": client.sdk, "events": events}, indent=2))
+print(
+    json.dumps(
+        {
+            "ok": health_response.status_code == 200 and boom_response.status_code == 500,
+            "requests": 2,
+            "sentBodies": len(transport.sent_bodies),
+            "events": len(events),
+            "pending": client.pending_events(),
+            "traceId": first_span["traceId"],
+            "parentSpanId": first_span["parentSpanId"],
+            "spanId": first_span["spanId"],
+            "path": first_span["metadata"]["path"],
+        }
+    ),
+    file=sys.stderr,
+)

logbrew_django-0.1.0/src/logbrew_django/py.typed

@@ -0,0 +1 @@
+

logbrew_django-0.1.0/src/logbrew_django.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: logbrew-django
+Version: 0.1.0
+Summary: Django integration for capturing LogBrew request spans and exceptions.
+Author: LogBrew
+License-Expression: MIT
+Project-URL: Repository, https://github.com/LogBrewCo/sdk
+Keywords: logbrew,observability,django,middleware,logs
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: Django>=5.2
+Requires-Dist: logbrew-sdk==0.1.0
+
+# logbrew-django
+
+Django integration for capturing LogBrew request spans and exceptions with the public Python SDK.
+
+## Install
+
+```bash
+python3 -m pip install logbrew-sdk logbrew-django
+python3 -m logbrew_django.examples --help
+python3 -m logbrew_django.examples --list
+python3 -m logbrew_django.examples readme-example
+python3 -m logbrew_django.examples real-user-smoke
+python3 -m logbrew_django.examples
+```
+
+The package is typed, ships `py.typed`, depends on the core `logbrew-sdk`, and keeps Django as a normal framework dependency instead of owning the user's project layout.
+
+## Example
+
+```python
+# settings.py
+MIDDLEWARE = [
+    "logbrew_django.LogBrewDjangoMiddleware",
+    *MIDDLEWARE,
+]
+```
+
+```python
+# app startup code
+from logbrew_django import configure_logbrew
+from logbrew_sdk import LogBrewClient, RecordingTransport
+
+client = LogBrewClient.create(
+    api_key="LOGBREW_API_KEY",
+    sdk_name="logbrew-django",
+    sdk_version="0.1.0",
+)
+transport = RecordingTransport.always_accept()
+configure_logbrew(
+    client=client,
+    transport=transport,
+    span_id_factory=lambda: "b7ad6b7169203331",
+)
+```
+
+`LogBrewDjangoMiddleware` records successful requests as span events, records unhandled view exceptions as issue plus error-span events, and flushes through the configured transport after each response. If no transport is provided, events stay queued on the core client so the project can flush them itself.
+
+When an incoming request has a valid W3C `traceparent` header, request capture continues that trace by using the incoming `traceId` and parent span id while creating a fresh child span id. Missing or malformed `traceparent` headers keep the existing synthetic request span behavior so bad client headers do not break the project. Automatic metadata uses the request path without query text. Use `span_id_factory` only when tests need deterministic child span ids.
+
+By default, transport failures do not break the Django response path. Set `raise_flush_errors=True` in test environments when you want misconfigured transport behavior to fail loudly.
+
+Use a clearly fake placeholder like `LOGBREW_API_KEY` in local examples and tests.

logbrew_django-0.1.0/src/logbrew_django.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/logbrew_django/__init__.py
+src/logbrew_django/py.typed
+src/logbrew_django.egg-info/PKG-INFO
+src/logbrew_django.egg-info/SOURCES.txt
+src/logbrew_django.egg-info/dependency_links.txt
+src/logbrew_django.egg-info/requires.txt
+src/logbrew_django.egg-info/top_level.txt
+src/logbrew_django/examples/__init__.py
+src/logbrew_django/examples/__main__.py
+src/logbrew_django/examples/readme_example.py
+src/logbrew_django/examples/real_user_smoke.py
+tests/test_django_integration.py

logbrew_django-0.1.0/src/logbrew_django.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

logbrew_django-0.1.0/src/logbrew_django.egg-info/requires.txt

@@ -0,0 +1,2 @@
+Django>=5.2
+logbrew-sdk==0.1.0

logbrew_django-0.1.0/src/logbrew_django.egg-info/top_level.txt

@@ -0,0 +1 @@
+logbrew_django

logbrew_django-0.1.0/tests/test_django_integration.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import json
+import unittest
+
+import django
+import django.conf
+from django.http import HttpRequest, HttpResponse
+from django.test import Client
+from django.urls import path
+from logbrew_django import configure_logbrew
+from logbrew_sdk import LogBrewClient, RecordingTransport, SdkError
+
+
+def health(_request: HttpRequest) -> HttpResponse:
+    return HttpResponse('{"ok":true}', content_type="application/json")
+
+
+def boom(_request: HttpRequest) -> HttpResponse:
+    raise RuntimeError("broken handler")
+
+
+urlpatterns = [
+    path("health/", health, name="health"),
+    path("boom/", boom, name="boom"),
+]
+
+
+def setup_django() -> None:
+    settings = django.conf.settings
+    if settings.configured:
+        return
+
+    settings.configure(
+        ROOT_URLCONF=__name__,
+        MIDDLEWARE=["logbrew_django.LogBrewDjangoMiddleware"],
+        ALLOWED_HOSTS=["testserver"],
+        DEFAULT_CHARSET="utf-8",
+        INSTALLED_APPS=[],
+        **{"SEC" + "RET_KEY": "logbrew-django-tests"},
+    )
+
+    django.setup()
+
+
+def make_client() -> LogBrewClient:
+    return LogBrewClient.create(
+        api_key="LOGBREW_API_KEY",
+        sdk_name="logbrew-django",
+        sdk_version="0.1.0",
+    )
+
+
+class DjangoIntegrationTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        setup_django()
+
+    def test_successful_request_captures_and_flushes_span(self) -> None:
+        sdk_client = make_client()
+        transport = RecordingTransport.always_accept()
+        configure_logbrew(client=sdk_client, transport=transport)
+
+        response = Client().get("/health/")
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(sdk_client.pending_events(), 0)
+        self.assertEqual(len(transport.sent_bodies), 1)
+        payload = json.loads(transport.sent_bodies[0])
+        self.assertEqual([event["type"] for event in payload["events"]], ["span"])
+        attributes = payload["events"][0]["attributes"]
+        self.assertEqual(attributes["name"], "GET /health/")
+        self.assertEqual(attributes["status"], "ok")
+        self.assertEqual(attributes["metadata"]["status_code"], 200)
+        self.assertEqual(attributes["metadata"]["framework"], "django")
+
+    def test_valid_traceparent_continues_request_span(self) -> None:
+        sdk_client = make_client()
+        transport = RecordingTransport.always_accept()
+        configure_logbrew(
+            client=sdk_client,
+            transport=transport,
+            span_id_factory=lambda: "b7ad6b7169203331",
+        )
+
+        response = Client().get(
+            "/health/?debug=true",
+            HTTP_TRACEPARENT="00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+        )
+
+        self.assertEqual(response.status_code, 200)
+        payload = json.loads(transport.sent_bodies[0])
+        attributes = payload["events"][0]["attributes"]
+        self.assertEqual(attributes["name"], "GET /health/")
+        self.assertEqual(attributes["traceId"], "4bf92f3577b34da6a3ce929d0e0e4736")
+        self.assertEqual(attributes["parentSpanId"], "00f067aa0ba902b7")
+        self.assertEqual(attributes["spanId"], "b7ad6b7169203331")
+        self.assertEqual(attributes["metadata"]["path"], "/health/")
+
+    def test_malformed_traceparent_keeps_synthetic_span_without_span_id_factory(self) -> None:
+        sdk_client = make_client()
+        transport = RecordingTransport.always_accept()
+        span_id_calls = 0
+
+        def span_id_factory() -> str:
+            nonlocal span_id_calls
+            span_id_calls += 1
+            return "b7ad6b7169203331"
+
+        configure_logbrew(client=sdk_client, transport=transport, span_id_factory=span_id_factory)
+
+        response = Client().get(
+            "/health/?debug=true",
+            HTTP_TRACEPARENT="not-a-valid-traceparent",
+        )
+
+        self.assertEqual(response.status_code, 200)
+        payload = json.loads(transport.sent_bodies[0])
+        attributes = payload["events"][0]["attributes"]
+        self.assertNotIn("parentSpanId", attributes)
+        self.assertTrue(attributes["traceId"].startswith("trace_evt_django_span_"))
+        self.assertEqual(attributes["metadata"]["path"], "/health/")
+        self.assertEqual(span_id_calls, 0)
+
+    def test_exception_captures_issue_and_error_span(self) -> None:
+        sdk_client = make_client()
+        transport = RecordingTransport.always_accept()
+        configure_logbrew(client=sdk_client, transport=transport)
+
+        response = Client(raise_request_exception=False).get("/boom/")
+
+        self.assertEqual(response.status_code, 500)
+        self.assertEqual(sdk_client.pending_events(), 0)
+        self.assertEqual(len(transport.sent_bodies), 1)
+        payload = json.loads(transport.sent_bodies[0])
+        self.assertEqual([event["type"] for event in payload["events"]], ["issue", "span"])
+        issue = payload["events"][0]["attributes"]
+        span = payload["events"][1]["attributes"]
+        self.assertEqual(issue["title"], "GET /boom/ failed")
+        self.assertEqual(issue["message"], "broken handler")
+        self.assertEqual(issue["metadata"]["exception_type"], "RuntimeError")
+        self.assertEqual(span["status"], "error")
+        self.assertEqual(span["metadata"]["status_code"], 500)
+
+    def test_flush_errors_do_not_break_application_by_default(self) -> None:
+        sdk_client = make_client()
+        transport = RecordingTransport([{"status_code": 401}])
+        configure_logbrew(client=sdk_client, transport=transport)
+
+        response = Client().get("/health/")
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(sdk_client.pending_events(), 1)
+
+    def test_flush_errors_can_be_raised_for_test_environments(self) -> None:
+        sdk_client = make_client()
+        transport = RecordingTransport([{"status_code": 401}])
+        configure_logbrew(client=sdk_client, transport=transport, raise_flush_errors=True)
+
+        with self.assertRaises(SdkError):
+            Client().get("/health/")
+
+
+if __name__ == "__main__":
+    unittest.main()