---
title: "Configurez le logging Django et gardez la stack trace de chaque erreur 500"
description: "Avec DEBUG = False et sans LOGGING, Django n’a écrit aucune stack trace pour une erreur 500. Voici la configuration LOGGING, les niveaux de log et l’envoi des erreurs à LogBrew, testés sur Django 6.1."
canonical: "https://logbrew.co/fr/guides/django-logging"
last_updated: "2026-11-21"
---

# Configurez le logging Django et gardez la stack trace de chaque erreur 500

Avec `DEBUG = False` et sans `LOGGING`, Django n’a écrit aucune stack trace pour une erreur 500. Voici la configuration `LOGGING`, les niveaux de log et l’envoi des erreurs à LogBrew, testés sur Django 6.1.

Testé le 21 novembre 2026 avec Python 3.13.5, Django 6.1.3, logbrew-sdk 0.1.29, logbrew-django 0.1.12 et logbrew CLI 0.1.96

Par [Furkan Erday](https://github.com/furkanerday). Furkan Erday est le fondateur de LogBrew. Il développe LogBrew avec Claude Code et Codex tous les jours.

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

## Ce que Django écrit sans `LOGGING`, et ce que LogBrew reçoit

| Événement | Écrit sans `LOGGING` | Problème ou log dans LogBrew |
| --- | --- | --- |
| `logger.debug()` | Ignoré | Ignoré au niveau `INFO` |
| `logger.info()` | Ignoré | Log `info` |
| `logger.warning()` | Message seul | Log `warning` |
| `logger.exception()` | Message et stack trace | Log avec l’exception |
| `ValueError` dans une vue | Ligne d’accès seule | Problème |
| `Http404` | Ligne d’accès seule | Span, sans problème |

6 événements dans Django 6.1.3 avec `DEBUG = False`, puis les mêmes avec notre dict `LOGGING` et logbrew-django 0.1.12.

## Configurer le logging Django

### Voyez ce que Django écrit sans LOGGING

Notre application a 1 logger nommé `taproom` et 4 vues. Avec `DEBUG = False` et sans `LOGGING`, Django a écrit `warning` et au-dessus en texte brut, et a ignoré `debug` et `info`. L’erreur 500 n’a donné que sa ligne d’accès, sans stack trace.

```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),
]
```

Sortie

```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
```

### Ajoutez un dict LOGGING à settings.py

Envoyez le logger racine vers la console et laissez `disable_existing_loggers` à `False` pour garder les loggers de Django actifs. `django.request` a alors écrit l’erreur 500 avec sa stack trace au niveau `ERROR`, et le 404 au niveau `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"),
    },
}
```

Sortie

```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
```

### Lisez le niveau dans l’environnement

Le dict `LOGGING` ci-dessus lit `LOG_LEVEL`. Lancez le serveur avec `LOG_LEVEL=DEBUG` et la ligne `debug` apparaît, sans changer le code.

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

Sortie

```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
```

### Loggez une exception capturée avec logger.exception()

Dans `except`, `logger.exception()` écrit au niveau `ERROR` et ajoute la stack trace. Notre vue `pay` a aussi renvoyé une réponse 402, donc `django.request` a écrit `Payment Required` au niveau `WARNING`.

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

Sortie

```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/
```

## Envoyer les logs et les erreurs Django à LogBrew

### Installez les paquets

`logbrew-django` ajoute un span pour chaque requête et enregistre chaque erreur non gérée d’une vue comme un problème. `logbrew-sdk` contient le client et le handler de logging. Utilisez une clé serveur de votre projet LogBrew.

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

### Ajoutez le middleware et le handler à settings.py

Placez ce code après `MIDDLEWARE` et `LOGGING`. `LogBrewDjangoMiddleware` doit venir en premier dans `MIDDLEWARE`. `LogBrewLoggingHandler` envoie chaque enregistrement du logger `taproom`. Nous avons envoyé vers un serveur LogBrew local, donc notre copie a passé `endpoint=` à `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"
)
```

### Relisez le problème et les logs

Nous avons rappelé les 4 vues, puis lu le projet avec une clé de lecture. L’erreur 500 est devenue 1 problème nommé d’après la route. Les logs `taproom` ont gardé leur niveau, et `debug` est resté absent, car le niveau racine était `INFO`. Le 404 n’a créé aucun problème.

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

Sortie

```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]
```

### Vérifiez ce que gardent le problème et le log

Le problème garde le type de l’exception et la route, mais pas le message. LogBrew écrit `Unhandled exception` à sa place. Le log de `logger.exception()` garde le nom et le message de l’exception, le fichier, la fonction et la ligne.

```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
  }'
```

Sortie

```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
}
```

## Ce que nous avons constaté en testant

Nous avons lancé 1 application Django 6.1.3 sur Python 3.13.5 avec `runserver` et `DEBUG = False`, appelé 4 vues avec curl et lu la sortie du serveur. Ensuite, nous avons ajouté logbrew-django 0.1.12 et lu ce qu’un serveur LogBrew local a stocké.

Avec `DEBUG = True` et sans `LOGGING`, Django a aussi écrit la stack trace de l’erreur 500. Une application qui affiche des stack traces en développement peut donc n’en afficher aucune en production.

|  | Sans `LOGGING` | Avec `LOGGING` |
| --- | --- | --- |
| `logger.debug()` | Non | Avec `LOG_LEVEL=DEBUG` |
| `logger.info()` | Non | Oui |
| `logger.warning()` | Oui | Oui |
| Stack trace de l’erreur 500 | Non | Oui |
| Ligne du 404 | Non | Oui |

## Les niveaux de log Django et le logger django.request

Django utilise les 5 niveaux de Python, `DEBUG`, `INFO`, `WARNING`, `ERROR` et `CRITICAL`. Le niveau racine de `LOGGING` ignore chaque enregistrement en dessous.

`django.request` écrit une réponse 5xx au niveau `ERROR` et une réponse 4xx au niveau `WARNING`. Seul le 500 issu d’une exception avait une stack trace.

LogBrew garde `warning`, `error` et `critical` tels quels, et stocke `DEBUG` et `INFO` comme `info`.

| Réponse | `django.request` | Stack trace |
| --- | --- | --- |
| `500` | `ERROR` | Oui |
| `404` | `WARNING` | Non |
| `402` | `WARNING` | Non |

## Ce que LogBrew enregistre

Le middleware enregistre 1 span par requête, nommé d’après le modèle de route, par exemple `GET /kegs/<int:keg_id>/`. Une exception dans une vue ajoute un problème avec le type de l’exception, le mécanisme `django.middleware` et `handled: false`.

Le problème ne garde pas le message de l’exception. Pour le garder, loggez l’erreur avec `logger.exception()`, comme le fait la vue `pay`.

Un log écrit pendant une requête porte l’ID de trace de cette requête. `Http404` et les autres exceptions 4xx créent un span avec leur statut, sans problème.

- `LogBrewDjangoMiddleware`
  - Problème: `GET /kegs/<int:keg_id>/ failed`
  - `exception.type`: `ValueError`
  - `mechanism`: `django.middleware`
  - `handled`: `false`
  - Frames de stack trace: 2
- `LogBrewLoggingHandler`
  - Message: `payment failed`
  - `exceptionName`: `CardDeclined`
  - `exceptionMessage`: `card declined`
  - `lineNumber`: `34`

## Questions fréquentes

### Pourquoi Django ne logge-t-il pas les erreurs 500 ?

Avec `DEBUG = False`, la configuration par défaut envoie les erreurs de `django.request` seulement à `mail_admins`, qui les envoie par e-mail aux `ADMINS`. Ajoutez un dict `LOGGING` avec un handler console sur le logger racine pour les afficher.

### Comment définir le niveau de log dans Django ?

Définissez `level` sur le logger racine dans `LOGGING`. Lisez-le dans une variable d’environnement comme `LOG_LEVEL` pour le changer sans modifier le code.

### Comment logger une exception avec sa stack trace dans Django ?

Appelez `logger.exception()` dans `except`. Il écrit au niveau `ERROR` et ajoute la stack trace.

### À quoi sert disable_existing_loggers ?

Avec `True`, les loggers de Django s’arrêtent dès que votre `LOGGING` s’applique, et `django.request` n’écrit plus rien. Gardez `False`.

## Voyez chaque erreur Django avec sa requête

logbrew-django enregistre chaque erreur non gérée d’une vue comme un problème nommé d’après sa route, et envoie vos logs avec la trace de leur requête. Commencez avec le forfait Free généreux, sans carte bancaire.

[Commencer gratuitement](https://logbrew.co/fr)

## Sources

- [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)

## Autres guides pour les agents, Python, Node.js et React

- [Ajouter un serveur MCP à Claude Code et Codex](https://logbrew.co/fr/guides/mcp-server-claude-code-codex)
- [Utiliser AGENTS.md dans Claude Code et Codex](https://logbrew.co/fr/guides/agents-md)
- [Corriger l’erreur Claude overloaded 529 et l’erreur rate limit 429](https://logbrew.co/fr/guides/claude-overloaded-rate-limit-error)
- [Configurer le module Python logging avec les bons niveaux de log et la capture des exceptions](https://logbrew.co/fr/guides/python-logging)
- [Structured logging avec un format de log et des niveaux que vous cherchez par champ](https://logbrew.co/fr/guides/structured-logging)
- [Configurer le logging Node.js avec Pino ou Winston sans perdre une seule erreur](https://logbrew.co/fr/guides/node-logging)
- [Configurez le logging FastAPI et gérez les erreurs sans perdre la stack trace](https://logbrew.co/fr/guides/fastapi-logging)
- [Ajoutez un périmètre d’erreur React et loggez les erreurs qu’il laisse passer](https://logbrew.co/fr/guides/react-error-boundary)
- [Trace ID vs span ID, décodés depuis un vrai en-tête traceparent](https://logbrew.co/fr/guides/trace-id)
- [Guides sur les erreurs, logs, traces, métriques et versions](https://logbrew.co/fr/guides)
