---
title: "Configura il logging di Django e conserva lo stack trace di ogni errore 500"
description: "Con DEBUG = False e senza LOGGING, Django non ha stampato nessuno stack trace per un errore 500. Ecco la configurazione di LOGGING, i livelli di log e come inviare gli errori a LogBrew, provati su Django 6.1."
canonical: "https://logbrew.co/it/guides/django-logging"
last_updated: "2026-11-21"
---

# Configura il logging di Django e conserva lo stack trace di ogni errore 500

Con `DEBUG = False` e senza `LOGGING`, Django non ha stampato nessuno stack trace per un errore 500. Ecco la configurazione di `LOGGING`, i livelli di log e come inviare gli errori a LogBrew, provati su Django 6.1.

Testato il 21 novembre 2026 con Python 3.13.5, Django 6.1.3, logbrew-sdk 0.1.29, logbrew-django 0.1.12 e logbrew CLI 0.1.96

Di [Furkan Erday](https://github.com/furkanerday). Furkan Erday è il fondatore di LogBrew. Sviluppa LogBrew ogni giorno con Claude Code e Codex.

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

## Cosa stampa Django senza `LOGGING` e cosa riceve LogBrew

| Evento | Stampato senza `LOGGING` | Problema o log registrato da LogBrew |
| --- | --- | --- |
| `logger.debug()` | Scartato | Scartato a `INFO` |
| `logger.info()` | Scartato | Log `info` |
| `logger.warning()` | Solo il messaggio | Log `warning` |
| `logger.exception()` | Messaggio e stack trace | Log con l’eccezione |
| `ValueError` in una view | Solo la riga di accesso | Problema |
| `Http404` | Solo la riga di accesso | Span, nessun problema |

6 eventi in Django 6.1.3 con `DEBUG = False`, poi gli stessi con il nostro dict `LOGGING` e logbrew-django 0.1.12.

## Configura il logging di Django

### Guarda cosa stampa Django senza LOGGING

La nostra app ha 1 logger chiamato `taproom` e 4 view. Con `DEBUG = False` e senza `LOGGING`, Django ha stampato `warning` e i livelli superiori come testo semplice, e ha scartato `debug` e `info`. L’errore 500 ha lasciato solo la riga di accesso, senza 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),
]
```

Output

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

### Aggiungi un dict LOGGING a settings.py

Manda il logger radice alla console e lascia `disable_existing_loggers` a `False`, così i logger di Django restano attivi. Ora `django.request` ha stampato l’errore 500 con lo stack trace a livello `ERROR`, e il 404 a livello `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"),
    },
}
```

Output

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

### Leggi il livello dall’ambiente

Il dict `LOGGING` qui sopra legge `LOG_LEVEL`. Avvia il server con `LOG_LEVEL=DEBUG` e compare la riga `debug`, senza cambiare il codice.

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

Output

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

### Registra un’eccezione intercettata con logger.exception()

Dentro `except`, `logger.exception()` scrive a livello `ERROR` e aggiunge lo stack trace. La nostra view `pay` ha anche restituito una risposta 402, quindi `django.request` ha scritto `Payment Required` a livello `WARNING`.

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

Output

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

## Invia log ed errori di Django a LogBrew

### Installa i pacchetti

`logbrew-django` aggiunge uno span per ogni richiesta e registra ogni errore non gestito di una view come problema. `logbrew-sdk` contiene il client e l’handler di logging. Usa una chiave server del tuo progetto LogBrew.

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

### Aggiungi middleware e handler a settings.py

Metti questo codice dopo `MIDDLEWARE` e `LOGGING`. `LogBrewDjangoMiddleware` deve venire per primo in `MIDDLEWARE`. `LogBrewLoggingHandler` invia ogni record del logger `taproom`. Abbiamo inviato a un server LogBrew locale, quindi la nostra copia ha passato `endpoint=` a `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"
)
```

### Rileggi il problema e i log

Abbiamo richiamato le 4 view e letto il progetto con una chiave di lettura. L’errore 500 è diventato 1 problema con il nome della route. I log di `taproom` hanno mantenuto il loro livello, e `debug` è rimasto fuori perché il livello radice era `INFO`. Il 404 non ha creato nessun problema.

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

Output

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

### Controlla cosa conservano il problema e il log

Il problema conserva il tipo di eccezione e la route, ma non il messaggio. LogBrew scrive `Unhandled exception` al suo posto. Il log di `logger.exception()` conserva nome e messaggio dell’eccezione, il file, la funzione e la riga.

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

Output

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

## Cosa abbiamo visto nei test

Abbiamo eseguito 1 app Django 6.1.3 su Python 3.13.5 con `runserver` e `DEBUG = False`, chiamato 4 view con curl e letto l’output del server. Poi abbiamo aggiunto logbrew-django 0.1.12 e letto cosa ha salvato un server LogBrew locale.

Con `DEBUG = True` e senza `LOGGING`, Django ha stampato anche lo stack trace dell’errore 500. Quindi un’app che stampa gli stack trace in sviluppo può non stamparne nessuno in produzione.

|  | Senza `LOGGING` | Con `LOGGING` |
| --- | --- | --- |
| `logger.debug()` | No | Con `LOG_LEVEL=DEBUG` |
| `logger.info()` | No | Sì |
| `logger.warning()` | Sì | Sì |
| Traceback dell’errore 500 | No | Sì |
| Riga del 404 | No | Sì |

## Livelli di log di Django e il logger django.request

Django usa i 5 livelli di Python, `DEBUG`, `INFO`, `WARNING`, `ERROR` e `CRITICAL`. Il livello radice in `LOGGING` scarta ogni record al di sotto.

`django.request` scrive una risposta 5xx a livello `ERROR` e una 4xx a livello `WARNING`. Solo il 500 nato da un’eccezione aveva lo stack trace.

LogBrew conserva `warning`, `error` e `critical` così come sono, e salva `DEBUG` e `INFO` come `info`.

| Risposta | `django.request` | Traceback |
| --- | --- | --- |
| `500` | `ERROR` | Sì |
| `404` | `WARNING` | No |
| `402` | `WARNING` | No |

## Cosa registra LogBrew

Il middleware registra 1 span per richiesta, con il nome del template della route, per esempio `GET /kegs/<int:keg_id>/`. Un’eccezione in una view aggiunge un problema con il tipo di eccezione, il meccanismo `django.middleware` e `handled: false`.

Il problema non conserva il messaggio dell’eccezione. Per conservarlo, registra l’errore con `logger.exception()`, come fa la view `pay`.

Un log scritto durante una richiesta porta l’ID della traccia di quella richiesta. `Http404` e le altre eccezioni 4xx creano uno span con il loro stato e nessun problema.

- `LogBrewDjangoMiddleware`
  - Problema: `GET /kegs/<int:keg_id>/ failed`
  - `exception.type`: `ValueError`
  - `mechanism`: `django.middleware`
  - `handled`: `false`
  - Frame dello stack: 2
- `LogBrewLoggingHandler`
  - Messaggio: `payment failed`
  - `exceptionName`: `CardDeclined`
  - `exceptionMessage`: `card declined`
  - `lineNumber`: `34`

## Domande frequenti

### Perché Django non registra gli errori 500?

Con `DEBUG = False`, la configurazione predefinita manda gli errori di `django.request` solo a `mail_admins`, che li invia per email agli `ADMINS`. Aggiungi un dict `LOGGING` con un handler console sul logger radice per stamparli.

### Come imposto il livello di logging in Django?

Imposta `level` sul logger radice in `LOGGING`. Leggilo da una variabile d’ambiente come `LOG_LEVEL` per cambiarlo senza toccare il codice.

### Come registro un’eccezione con lo stack trace in Django?

Chiama `logger.exception()` dentro `except`. Scrive a livello `ERROR` e aggiunge lo stack trace.

### A cosa serve disable_existing_loggers?

Con `True`, i logger di Django si fermano quando si applica il tuo `LOGGING`, quindi `django.request` non stampa niente. Lascialo a `False`.

## Vedi ogni errore Django con la sua richiesta

logbrew-django registra ogni errore non gestito di una view come problema con il nome della sua route, e invia i tuoi log con la traccia della loro richiesta. Inizia con il generoso piano gratuito, senza carta.

[Inizia gratis](https://logbrew.co/it)

## Fonti

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

## Altre guide per gli agenti, Python, Node.js e React

- [Aggiungi un server MCP a Claude Code e Codex](https://logbrew.co/it/guides/mcp-server-claude-code-codex)
- [Usa AGENTS.md in Claude Code e Codex](https://logbrew.co/it/guides/agents-md)
- [Risolvi l’errore overloaded 529 e l’errore di rate limit 429 di Claude](https://logbrew.co/it/guides/claude-overloaded-rate-limit-error)
- [Configura il modulo Python logging con i livelli di log giusti e la cattura delle eccezioni](https://logbrew.co/it/guides/python-logging)
- [Structured logging con un formato dei log e livelli che puoi cercare per campo](https://logbrew.co/it/guides/structured-logging)
- [Configura il logging in Node.js con Pino o Winston senza perdere nessun errore](https://logbrew.co/it/guides/node-logging)
- [Configura il logging di FastAPI e gestisci gli errori senza perdere lo stack trace](https://logbrew.co/it/guides/fastapi-logging)
- [Aggiungi un boundary di errore React e registra gli errori che si lascia sfuggire](https://logbrew.co/it/guides/react-error-boundary)
- [ID traccia vs ID span, decodificati da un vero header traceparent](https://logbrew.co/it/guides/trace-id)
- [Guide su errori, log, tracce, metriche e release](https://logbrew.co/it/guides)
