---
title: "Stel Django-logging in en bewaar de stacktrace van elke 500-fout"
description: "Met DEBUG = False en zonder LOGGING schreef Django geen stacktrace voor een 500-fout. Hier lees je de LOGGING-instelling, de logniveaus en hoe je fouten naar LogBrew stuurt, getest op Django 6.1."
canonical: "https://logbrew.co/nl/guides/django-logging"
last_updated: "2026-11-21"
---

# Stel Django-logging in en bewaar de stacktrace van elke 500-fout

Met `DEBUG = False` en zonder `LOGGING` schreef Django geen stacktrace voor een 500-fout. Hier lees je de `LOGGING`-instelling, de logniveaus en hoe je fouten naar LogBrew stuurt, getest op Django 6.1.

Getest op 21 november 2026 met Python 3.13.5, Django 6.1.3, logbrew-sdk 0.1.29, logbrew-django 0.1.12 en logbrew CLI 0.1.96

Door [Furkan Erday](https://github.com/furkanerday). Furkan Erday is de oprichter van LogBrew. Hij bouwt LogBrew elke dag met Claude Code en Codex.

Canonical: https://logbrew.co/nl/guides/django-logging

## Wat Django zonder `LOGGING` schrijft, en wat LogBrew krijgt

| Event | Geschreven zonder `LOGGING` | Issue of log in LogBrew |
| --- | --- | --- |
| `logger.debug()` | Weggelaten | Weggelaten bij `INFO` |
| `logger.info()` | Weggelaten | `info`-log |
| `logger.warning()` | Alleen het bericht | `warning`-log |
| `logger.exception()` | Bericht en stacktrace | Log met de exception |
| `ValueError` in een view | Alleen de toegangsregel | Issue |
| `Http404` | Alleen de toegangsregel | Span, geen issue |

6 events in Django 6.1.3 met `DEBUG = False`, daarna dezelfde met onze `LOGGING`-dict en logbrew-django 0.1.12.

## Django-logging configureren

### Bekijk wat Django zonder LOGGING schrijft

Onze app heeft 1 logger met de naam `taproom` en 4 views. Met `DEBUG = False` en zonder `LOGGING` schreef Django `warning` en hoger als kale tekst, en liet `debug` en `info` vallen. De 500-fout gaf alleen een toegangsregel, zonder stacktrace.

```bash
import logging

from django.http import Http404, JsonResponse
from django.urls import path

logger = logging.getLogger("taproom")


class CardDeclined(Exception):
    pass


def pour(request, tap):
    logger.debug("keg pressure read")
    logger.info("tap %s opened", tap)
    logger.warning("keg below 10%")
    logger.error("keg empty")
    logger.critical("cooler offline")
    return JsonResponse({"tap": tap})


def keg(request, keg_id):
    raise ValueError(f"keg {keg_id} is empty")


def missing(request):
    raise Http404("no such tap")


def pay(request):
    try:
        raise CardDeclined("card declined")
    except CardDeclined:
        logger.exception("payment failed")
        return JsonResponse({"error": "card declined"}, status=402)


urlpatterns = [
    path("taps/<str:tap>/", pour),
    path("kegs/<int:keg_id>/", keg),
    path("missing/", missing),
    path("pay/", pay),
]
```

Uitvoer

```text
keg below 10%
keg empty
cooler offline
[21/Nov/2026 00:41:16] "GET /taps/ipa/ HTTP/1.1" 200 14
[21/Nov/2026 00:41:16] "GET /kegs/7/ HTTP/1.1" 500 145
[21/Nov/2026 00:41:16] "GET /missing/ HTTP/1.1" 404 179
payment failed
Traceback (most recent call last):
  File "urls.py", line 32, in pay
    raise CardDeclined("card declined")
urls.CardDeclined: card declined
[21/Nov/2026 00:41:16] "GET /pay/ HTTP/1.1" 402 26
```

### Voeg een LOGGING-dict toe aan settings.py

Stuur de root-logger naar de console en laat `disable_existing_loggers` op `False` staan, zodat de eigen loggers van Django aan blijven. Nu schreef `django.request` de 500-fout met stacktrace op `ERROR`, en de 404 op `WARNING`.

```bash
LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {
        "plain": {"format": "{levelname} {name} {message}", "style": "{"},
    },
    "handlers": {
        "console": {"class": "logging.StreamHandler", "formatter": "plain"},
    },
    "root": {
        "handlers": ["console"],
        "level": os.environ.get("LOG_LEVEL", "INFO"),
    },
}
```

Uitvoer

```text
INFO taproom tap ipa opened
WARNING taproom keg below 10%
ERROR taproom keg empty
CRITICAL taproom cooler offline
[21/Nov/2026 00:41:20] "GET /taps/ipa/ HTTP/1.1" 200 14
ERROR django.request Internal Server Error: /kegs/7/
Traceback (most recent call last):
  File "django/core/handlers/exception.py", line 56, in inner
    response = get_response(request)
  File "django/core/handlers/base.py", line 199, in _get_response
    response = wrapped_callback(request, *callback_args, **callback_kwargs)
  File "urls.py", line 23, in keg
    raise ValueError(f"keg {keg_id} is empty")
ValueError: keg 7 is empty
[21/Nov/2026 00:41:20] "GET /kegs/7/ HTTP/1.1" 500 145
WARNING django.request Not Found: /missing/
[21/Nov/2026 00:41:20] "GET /missing/ HTTP/1.1" 404 179
ERROR taproom payment failed
Traceback (most recent call last):
  File "urls.py", line 32, in pay
    raise CardDeclined("card declined")
urls.CardDeclined: card declined
WARNING django.request Payment Required: /pay/
[21/Nov/2026 00:41:20] "GET /pay/ HTTP/1.1" 402 26
```

### Lees het niveau uit de omgeving

De `LOGGING`-dict hierboven leest `LOG_LEVEL`. Start de server met `LOG_LEVEL=DEBUG` en de `debug`-regel verschijnt, zonder codewijziging.

```bash
LOG_LEVEL=DEBUG python manage.py runserver
```

Uitvoer

```text
DEBUG taproom keg pressure read
INFO taproom tap ipa opened
WARNING taproom keg below 10%
ERROR taproom keg empty
CRITICAL taproom cooler offline
[21/Nov/2026 00:41:21] "GET /taps/ipa/ HTTP/1.1" 200 14
```

### Log een afgevangen exception met logger.exception()

Binnen `except` logt `logger.exception()` op `ERROR` en voegt de stacktrace toe. Onze view `pay` gaf ook een 402-response terug, dus `django.request` logde `Payment Required` op `WARNING`.

```bash
def pay(request):
    try:
        raise CardDeclined("card declined")
    except CardDeclined:
        logger.exception("payment failed")
        return JsonResponse({"error": "card declined"}, status=402)
```

Uitvoer

```text
ERROR taproom payment failed
Traceback (most recent call last):
  File "urls.py", line 32, in pay
    raise CardDeclined("card declined")
urls.CardDeclined: card declined
WARNING django.request Payment Required: /pay/
```

## Django-logs en -fouten naar LogBrew sturen

### Installeer de pakketten

`logbrew-django` maakt een span voor elk request en legt elke onafgehandelde fout van een view vast als issue. `logbrew-sdk` bevat de client en de logging-handler. Gebruik een serversleutel van je LogBrew-project.

```bash
python3 -m pip install logbrew-sdk logbrew-django
```

### Voeg de middleware en de handler toe aan settings.py

Zet deze code na `MIDDLEWARE` en `LOGGING`. `LogBrewDjangoMiddleware` moet als eerste in `MIDDLEWARE` staan. `LogBrewLoggingHandler` stuurt elk record van de logger `taproom`. Wij stuurden naar een lokale LogBrew-server, dus onze kopie gaf `endpoint=` mee aan `HttpTransport()`.

```bash
import logging
import os

from logbrew_django import configure_logbrew
from logbrew_sdk import HttpTransport, LogBrewClient, LogBrewLoggingHandler

MIDDLEWARE = ["logbrew_django.LogBrewDjangoMiddleware", *MIDDLEWARE]

client = LogBrewClient.create(api_key=os.environ["LOGBREW_SERVER_API_KEY"])
logging.getLogger("taproom").addHandler(LogBrewLoggingHandler(client))
configure_logbrew(
    client=client, transport=HttpTransport(), service_name="taproom"
)
```

### Lees het issue en de logs terug

We riepen de 4 views opnieuw aan en lazen het project met een leessleutel. De 500-fout werd 1 issue met de naam van de route. De `taproom`-logs hielden hun niveau, en `debug` bleef weg omdat het root-niveau `INFO` was. De 404 maakte geen issue.

```bash
logbrew issues --since 1h
logbrew read logs --since 1h
```

Uitvoer

```text
Issues (1)
- 4ca6e2fb-76d2-57d9-879a-5a4410756489 unresolved error priority=medium GET /kegs/<int:keg_id>/ failed occurrences=1 users=unknown last_seen=2026-11-21T06:44:49.579Z service=taproom trace=980168dd9976432da150838cb57f0f04 assignee=unassigned [unversioned / production]
Logs (5)
- error payment failed service=taproom trace=430c4481db414e84bec813f60aa9aa93 [unversioned / production]
- critical cooler offline service=taproom trace=a407e883564e4ab486dd9a4921971ad4 [unversioned / production]
- info tap ipa opened service=taproom trace=a407e883564e4ab486dd9a4921971ad4 [unversioned / production]
- warning keg below 10% service=taproom trace=a407e883564e4ab486dd9a4921971ad4 [unversioned / production]
- error keg empty service=taproom trace=a407e883564e4ab486dd9a4921971ad4 [unversioned / production]
```

### Controleer wat het issue en de log bewaren

Het issue bewaart het type exception en de route, maar niet het bericht. LogBrew schrijft daar `Unhandled exception`. De log van `logger.exception()` bewaart de naam en het bericht van de exception, het bestand, de functie en de regel.

```bash
logbrew issues --since 1h --json | jq '.[0].attributes | {
  message, exception,
  route: .metadata.routeTemplate,
  frames: (.stackFrames | length)
}'
logbrew read logs --since 1h --severity error --search payment --json |
  jq '.[0].attributes.metadata | {
    exceptionName, exceptionMessage, fileName, functionName, lineNumber
  }'
```

Uitvoer

```text
{
  "message": "Unhandled exception",
  "exception": {
    "mechanism": {
      "handled": false,
      "type": "django.middleware"
    },
    "type": "ValueError"
  },
  "route": "/kegs/<int:keg_id>/",
  "frames": 2
}
{
  "exceptionName": "CardDeclined",
  "exceptionMessage": "card declined",
  "fileName": "urls.py",
  "functionName": "pay",
  "lineNumber": 34
}
```

## Wat we zagen in onze test

We draaiden 1 Django 6.1.3-app op Python 3.13.5 met `runserver` en `DEBUG = False`, riepen 4 views aan met curl en lazen de serveroutput. Daarna voegden we logbrew-django 0.1.12 toe en lazen wat een lokale LogBrew-server opsloeg.

Met `DEBUG = True` en zonder `LOGGING` schreef Django ook de stacktrace van de 500-fout. Een app die in ontwikkeling stacktraces toont, toont er in productie dus misschien geen.

|  | Zonder `LOGGING` | Met `LOGGING` |
| --- | --- | --- |
| `logger.debug()` | Nee | Met `LOG_LEVEL=DEBUG` |
| `logger.info()` | Nee | Ja |
| `logger.warning()` | Ja | Ja |
| Stacktrace van de 500-fout | Nee | Ja |
| Regel voor de 404 | Nee | Ja |

## Django-logniveaus en de logger django.request

Django gebruikt de 5 niveaus van Python, `DEBUG`, `INFO`, `WARNING`, `ERROR` en `CRITICAL`. Het root-niveau in `LOGGING` laat elk record daaronder vallen.

`django.request` logt een 5xx-response op `ERROR` en een 4xx-response op `WARNING`. Alleen de 500 uit een exception had een stacktrace.

LogBrew houdt `warning`, `error` en `critical` zoals ze zijn, en slaat `DEBUG` en `INFO` op als `info`.

| Response | `django.request` | Stacktrace |
| --- | --- | --- |
| `500` | `ERROR` | Ja |
| `404` | `WARNING` | Nee |
| `402` | `WARNING` | Nee |

## Wat LogBrew vastlegt

De middleware legt 1 span per request vast, met de naam van het routetemplate, zoals `GET /kegs/<int:keg_id>/`. Een exception in een view voegt een issue toe met het type exception, het mechanisme `django.middleware` en `handled: false`.

Het issue bewaart het bericht van de exception niet. Wil je het bewaren, log de fout dan met `logger.exception()`, zoals de view `pay` doet.

Een log die tijdens een request ontstaat, draagt de trace-ID van dat request. `Http404` en de andere 4xx-exceptions maken een span met hun status en geen issue.

- `LogBrewDjangoMiddleware`
  - Issue: `GET /kegs/<int:keg_id>/ failed`
  - `exception.type`: `ValueError`
  - `mechanism`: `django.middleware`
  - `handled`: `false`
  - Stackframes: 2
- `LogBrewLoggingHandler`
  - Melding: `payment failed`
  - `exceptionName`: `CardDeclined`
  - `exceptionMessage`: `card declined`
  - `lineNumber`: `34`

## Veelgestelde vragen

### Waarom logt Django geen 500-fouten?

Met `DEBUG = False` stuurt de standaardinstelling fouten van `django.request` alleen naar `mail_admins`, en die mailt ze naar de `ADMINS`. Voeg een `LOGGING`-dict toe met een consolehandler op de root-logger om ze te tonen.

### Hoe stel ik het logniveau in Django in?

Zet `level` op de root-logger in `LOGGING`. Lees het uit een omgevingsvariabele zoals `LOG_LEVEL`, dan wijzig je het zonder codewijziging.

### Hoe log ik in Django een exception met stacktrace?

Roep `logger.exception()` aan binnen `except`. Het logt op `ERROR` en voegt de stacktrace toe.

### Wat doet disable_existing_loggers?

Met `True` stoppen de eigen loggers van Django zodra je `LOGGING` actief wordt, dus `django.request` schrijft niets meer. Laat het op `False`.

## Zie elke Django-fout met zijn request

logbrew-django legt elke onafgehandelde fout van een view vast als issue met de naam van de route, en stuurt je logs mee met de trace van hun request. Begin met het ruime gratis abonnement, zonder creditcard.

[Gratis beginnen](https://logbrew.co/nl)

## Bronnen

- [Django docs, Configuring logging](https://docs.djangoproject.com/en/6.0/topics/logging/#configuring-logging)
- [Django docs, Default logging configuration](https://docs.djangoproject.com/en/6.0/ref/logging/#django-s-default-logging-configuration)
- [Django docs, django.request](https://docs.djangoproject.com/en/6.0/ref/logging/#django-request)
- [django/django, django/utils/log.py](https://github.com/django/django/blob/main/django/utils/log.py)

## Meer handleidingen voor agents, Python, Node.js en React

- [Een MCP-server toevoegen aan Claude Code en Codex](https://logbrew.co/nl/guides/mcp-server-claude-code-codex)
- [AGENTS.md gebruiken in Claude Code en Codex](https://logbrew.co/nl/guides/agents-md)
- [Claude overloaded error 529 en rate limit error 429 oplossen](https://logbrew.co/nl/guides/claude-overloaded-rate-limit-error)
- [Python-logging instellen met de juiste logniveaus en exceptions met traceback](https://logbrew.co/nl/guides/python-logging)
- [Structured logging met een logformaat en logniveaus die je per veld doorzoekt](https://logbrew.co/nl/guides/structured-logging)
- [Node.js-logging instellen met Pino of Winston zonder één fout te missen](https://logbrew.co/nl/guides/node-logging)
- [Stel FastAPI-logging in en handel fouten af zonder de stacktrace te verliezen](https://logbrew.co/nl/guides/fastapi-logging)
- [Voeg een React error boundary toe en log de fouten die hij mist](https://logbrew.co/nl/guides/react-error-boundary)
- [Trace-ID vs span-ID, ontleed in een echte traceparent-header](https://logbrew.co/nl/guides/trace-id)
- [Handleidingen voor fouten, logs, traces, metrics en releases](https://logbrew.co/nl/guides)
