---
title: "Configure o logging do Django e guarde o stack trace de cada erro 500"
description: "Com DEBUG = False e sem LOGGING, o Django não imprimiu nenhum stack trace para um erro 500. Veja a configuração do LOGGING, os níveis de log e como enviar os erros ao LogBrew, testados no Django 6.1."
canonical: "https://logbrew.co/pt-BR/guides/django-logging"
last_updated: "2026-11-21"
---

# Configure o logging do Django e guarde o stack trace de cada erro 500

Com `DEBUG = False` e sem `LOGGING`, o Django não imprimiu nenhum stack trace para um erro 500. Veja a configuração do `LOGGING`, os níveis de log e como enviar os erros ao LogBrew, testados no Django 6.1.

Testado em 21 de novembro de 2026 com Python 3.13.5, Django 6.1.3, logbrew-sdk 0.1.29, logbrew-django 0.1.12 e logbrew CLI 0.1.96

Por [Furkan Erday](https://github.com/furkanerday). Furkan Erday é o fundador do LogBrew. Ele desenvolve o LogBrew com Claude Code e Codex todos os dias.

Canonical: https://logbrew.co/pt-BR/guides/django-logging

## O que o Django imprime sem `LOGGING` e o que o LogBrew recebe

| Evento | Impresso sem `LOGGING` | Problema ou log no LogBrew |
| --- | --- | --- |
| `logger.debug()` | Descartado | Descartado em `INFO` |
| `logger.info()` | Descartado | Log `info` |
| `logger.warning()` | Só a mensagem | Log `warning` |
| `logger.exception()` | Mensagem e stack trace | Log com a exceção |
| `ValueError` numa view | Só a linha de acesso | Problema |
| `Http404` | Só a linha de acesso | Span, sem problema |

6 eventos no Django 6.1.3 com `DEBUG = False`, depois os mesmos com o nosso dict `LOGGING` e o logbrew-django 0.1.12.

## Configure o logging do Django

### Veja o que o Django imprime sem LOGGING

Nosso app tem 1 logger chamado `taproom` e 4 views. Com `DEBUG = False` e sem `LOGGING`, o Django imprimiu `warning` e os níveis acima como texto puro, e descartou `debug` e `info`. O erro 500 gerou só a linha de acesso, sem 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),
]
```

Saída

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

### Adicione um dict LOGGING ao settings.py

Mande o logger raiz para o console e deixe `disable_existing_loggers` em `False` para os loggers do próprio Django continuarem ativos. Agora o `django.request` imprimiu o erro 500 com o stack trace em `ERROR`, e o 404 em `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"),
    },
}
```

Saída

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

### Leia o nível do ambiente

O dict `LOGGING` acima lê `LOG_LEVEL`. Inicie o servidor com `LOG_LEVEL=DEBUG` e a linha `debug` aparece, sem mudar o código.

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

Saída

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

### Registre uma exceção capturada com logger.exception()

Dentro do `except`, `logger.exception()` registra em `ERROR` e adiciona o stack trace. Nossa view `pay` também devolveu uma resposta 402, então o `django.request` registrou `Payment Required` em `WARNING`.

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

Saída

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

## Envie logs e erros do Django ao LogBrew

### Instale os pacotes

`logbrew-django` cria um span para cada requisição e registra cada erro não tratado de uma view como problema. `logbrew-sdk` traz o cliente e o handler de logging. Use uma chave de servidor do seu projeto LogBrew.

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

### Adicione o middleware e o handler ao settings.py

Coloque este código depois de `MIDDLEWARE` e `LOGGING`. `LogBrewDjangoMiddleware` precisa vir primeiro em `MIDDLEWARE`. `LogBrewLoggingHandler` envia cada registro do logger `taproom`. Enviamos para um servidor LogBrew local, então nossa cópia passou `endpoint=` para `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"
)
```

### Leia o problema e os logs de volta

Chamamos as 4 views de novo e lemos o projeto com uma chave de leitura. O erro 500 virou 1 problema com o nome da rota. Os logs de `taproom` mantiveram o nível, e `debug` ficou de fora porque o nível raiz era `INFO`. O 404 não criou problema.

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

Saída

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

### Confira o que o problema e o log guardam

O problema guarda o tipo da exceção e a rota, mas não a mensagem. O LogBrew escreve `Unhandled exception` no lugar dela. O log de `logger.exception()` guarda o nome e a mensagem da exceção, o arquivo, a função e a linha.

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

Saída

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

## O que vimos no teste

Rodamos 1 app Django 6.1.3 no Python 3.13.5 com `runserver` e `DEBUG = False`, chamamos 4 views com curl e lemos a saída do servidor. Depois adicionamos o logbrew-django 0.1.12 e lemos o que um servidor LogBrew local guardou.

Com `DEBUG = True` e sem `LOGGING`, o Django também imprimiu o stack trace do erro 500. Então um app que imprime stack traces em desenvolvimento pode não imprimir nenhum em produção.

|  | Sem `LOGGING` | Com `LOGGING` |
| --- | --- | --- |
| `logger.debug()` | Não | Com `LOG_LEVEL=DEBUG` |
| `logger.info()` | Não | Sim |
| `logger.warning()` | Sim | Sim |
| Stack trace do erro 500 | Não | Sim |
| Linha do 404 | Não | Sim |

## Níveis de log do Django e o logger django.request

O Django usa os 5 níveis do Python, `DEBUG`, `INFO`, `WARNING`, `ERROR` e `CRITICAL`. O nível raiz no `LOGGING` descarta cada registro abaixo dele.

O `django.request` registra uma resposta 5xx em `ERROR` e uma 4xx em `WARNING`. Só o 500 vindo de uma exceção trouxe stack trace.

O LogBrew mantém `warning`, `error` e `critical` como estão, e guarda `DEBUG` e `INFO` como `info`.

| Resposta | `django.request` | Stack trace |
| --- | --- | --- |
| `500` | `ERROR` | Sim |
| `404` | `WARNING` | Não |
| `402` | `WARNING` | Não |

## O que o LogBrew registra

O middleware registra 1 span por requisição, com o nome do template da rota, como `GET /kegs/<int:keg_id>/`. Uma exceção numa view adiciona um problema com o tipo da exceção, o mecanismo `django.middleware` e `handled: false`.

O problema não guarda a mensagem da exceção. Para guardá-la, registre o erro com `logger.exception()`, como faz a view `pay`.

Um log gerado durante uma requisição leva o ID do trace dessa requisição. `Http404` e as outras exceções 4xx criam um span com o status delas e nenhum problema.

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

## Perguntas frequentes

### Por que o Django não registra erros 500?

Com `DEBUG = False`, a configuração padrão manda os erros do `django.request` só para `mail_admins`, que envia por e-mail aos `ADMINS`. Adicione um dict `LOGGING` com um handler de console no logger raiz para imprimi-los.

### Como defino o nível de log no Django?

Defina `level` no logger raiz dentro do `LOGGING`. Leia o valor de uma variável de ambiente como `LOG_LEVEL` para mudar sem alterar o código.

### Como registro uma exceção com stack trace no Django?

Chame `logger.exception()` dentro do `except`. Ele registra em `ERROR` e adiciona o stack trace.

### O que faz o disable_existing_loggers?

Com `True`, os loggers do próprio Django param quando o seu `LOGGING` entra em vigor, e o `django.request` não imprime nada. Deixe em `False`.

## Veja cada erro do Django com a sua requisição

O logbrew-django registra cada erro não tratado de uma view como um problema com o nome da rota, e envia seus logs com o trace da requisição deles. Comece no plano gratuito generoso, sem cartão.

[Comece grátis](https://logbrew.co/pt-BR)

## Fontes

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

## Mais guias para agentes, Python, Node.js e React

- [Adicione um servidor MCP ao Claude Code e ao Codex](https://logbrew.co/pt-BR/guides/mcp-server-claude-code-codex)
- [Use AGENTS.md no Claude Code e no Codex](https://logbrew.co/pt-BR/guides/agents-md)
- [Corrija o erro 529 overloaded e o erro 429 de rate limit do Claude](https://logbrew.co/pt-BR/guides/claude-overloaded-rate-limit-error)
- [Configure o Python logging com os níveis de log certos e captura de exceções](https://logbrew.co/pt-BR/guides/python-logging)
- [Structured logging com formato de log e níveis que você busca por campo](https://logbrew.co/pt-BR/guides/structured-logging)
- [Configure o logging em Node.js com Pino ou Winston sem perder nenhum erro](https://logbrew.co/pt-BR/guides/node-logging)
- [Configure o logging do FastAPI e trate os erros sem perder o stack trace](https://logbrew.co/pt-BR/guides/fastapi-logging)
- [Adicione um error boundary no React e registre os erros que ele deixa passar](https://logbrew.co/pt-BR/guides/react-error-boundary)
- [Trace ID vs span ID, decodificados de um header traceparent real](https://logbrew.co/pt-BR/guides/trace-id)
- [Guias de erros, logs, traces, métricas e versões](https://logbrew.co/pt-BR/guides)
