---
title: "Configura el logging de Django y conserva la traza de pila de cada error 500"
description: "Con DEBUG = False y sin LOGGING, Django no imprimió ninguna traza de pila para un error 500. Aquí tienes la configuración de LOGGING, los niveles de log y cómo enviar los errores a LogBrew, probado en Django 6.1."
canonical: "https://logbrew.co/es/guides/django-logging"
last_updated: "2026-11-21"
---

# Configura el logging de Django y conserva la traza de pila de cada error 500

Con `DEBUG = False` y sin `LOGGING`, Django no imprimió ninguna traza de pila para un error 500. Aquí tienes la configuración de `LOGGING`, los niveles de log y cómo enviar los errores a LogBrew, probado en Django 6.1.

Probado el 21 de noviembre de 2026 con Python 3.13.5, Django 6.1.3, logbrew-sdk 0.1.29, logbrew-django 0.1.12 y logbrew CLI 0.1.96

Por [Furkan Erday](https://github.com/furkanerday). Furkan Erday es el fundador de LogBrew. Desarrolla LogBrew con Claude Code y Codex todos los días.

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

## Qué imprime Django sin `LOGGING` y qué recibe LogBrew

| Evento | Impreso sin `LOGGING` | Incidencia o log en LogBrew |
| --- | --- | --- |
| `logger.debug()` | Descartado | Descartado en `INFO` |
| `logger.info()` | Descartado | Log `info` |
| `logger.warning()` | Solo el mensaje | Log `warning` |
| `logger.exception()` | Mensaje y traza de pila | Log con la excepción |
| `ValueError` en una vista | Solo la línea de acceso | Incidencia |
| `Http404` | Solo la línea de acceso | Span, sin incidencia |

6 eventos en Django 6.1.3 con `DEBUG = False`, y luego los mismos con nuestro dict `LOGGING` y logbrew-django 0.1.12.

## Configura el logging de Django

### Mira qué imprime Django sin LOGGING

Nuestra app tiene 1 logger llamado `taproom` y 4 vistas. Con `DEBUG = False` y sin `LOGGING`, Django imprimió `warning` y los niveles superiores como texto plano, y descartó `debug` e `info`. El error 500 solo dejó su línea de acceso, sin traza de pila.

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

Salida

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

### Añade un dict LOGGING a settings.py

Envía el logger raíz a la consola y deja `disable_existing_loggers` en `False` para que los loggers propios de Django sigan activos. Ahora `django.request` imprimió el error 500 con su traza de pila en `ERROR`, y el 404 en `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"),
    },
}
```

Salida

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

### Lee el nivel del entorno

El dict `LOGGING` de arriba lee `LOG_LEVEL`. Inicia el servidor con `LOG_LEVEL=DEBUG` y aparece la línea `debug`, sin cambiar el código.

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

Salida

```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 una excepción capturada con logger.exception()

Dentro de `except`, `logger.exception()` registra en `ERROR` y añade la traza de pila. Nuestra vista `pay` también devolvió una respuesta 402, así que `django.request` registró `Payment Required` en `WARNING`.

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

Salida

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

## Envía los logs y errores de Django a LogBrew

### Instala los paquetes

`logbrew-django` añade un span por cada solicitud y registra cada error no controlado de una vista como incidencia. `logbrew-sdk` contiene el cliente y el handler de logging. Usa una clave de servidor de tu proyecto de LogBrew.

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

### Añade el middleware y el handler a settings.py

Pon este código después de `MIDDLEWARE` y `LOGGING`. `LogBrewDjangoMiddleware` debe ir primero en `MIDDLEWARE`. `LogBrewLoggingHandler` envía cada registro del logger `taproom`. Enviamos a un servidor local de LogBrew, así que nuestra copia pasó `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"
)
```

### Lee la incidencia y los logs

Volvimos a llamar a las 4 vistas y leímos el proyecto con una clave de lectura. El error 500 se convirtió en 1 incidencia con el nombre de la ruta. Los logs de `taproom` conservaron su nivel, y `debug` quedó fuera porque el nivel raíz era `INFO`. El 404 no creó ninguna incidencia.

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

Salida

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

### Comprueba qué conservan la incidencia y el log

La incidencia conserva el tipo de excepción y la ruta, pero no el mensaje. LogBrew escribe `Unhandled exception` en su lugar. El log de `logger.exception()` conserva el nombre y el mensaje de la excepción, el archivo, la función y la línea.

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

Salida

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

## Lo que vimos al probarlo

Ejecutamos 1 app de Django 6.1.3 en Python 3.13.5 con `runserver` y `DEBUG = False`, llamamos a 4 vistas con curl y leímos la salida del servidor. Después añadimos logbrew-django 0.1.12 y leímos lo que guardó un servidor local de LogBrew.

Con `DEBUG = True` y sin `LOGGING`, Django también imprimió la traza de pila del error 500. Así que una app que imprime trazas de pila en desarrollo puede no imprimir ninguna en producción.

|  | Sin `LOGGING` | Con `LOGGING` |
| --- | --- | --- |
| `logger.debug()` | No | Con `LOG_LEVEL=DEBUG` |
| `logger.info()` | No | Sí |
| `logger.warning()` | Sí | Sí |
| Traza de pila del error 500 | No | Sí |
| Línea del 404 | No | Sí |

## Niveles de log de Django y el logger django.request

Django usa los 5 niveles de Python, `DEBUG`, `INFO`, `WARNING`, `ERROR` y `CRITICAL`. El nivel raíz de `LOGGING` descarta cada registro por debajo de él.

`django.request` registra una respuesta 5xx en `ERROR` y una 4xx en `WARNING`. Solo el 500 que vino de una excepción traía traza de pila.

LogBrew conserva `warning`, `error` y `critical` tal cual, y guarda `DEBUG` e `INFO` como `info`.

| Respuesta | `django.request` | Traza de pila |
| --- | --- | --- |
| `500` | `ERROR` | Sí |
| `404` | `WARNING` | No |
| `402` | `WARNING` | No |

## Qué registra LogBrew

El middleware registra 1 span por solicitud, con el nombre de la plantilla de ruta, como `GET /kegs/<int:keg_id>/`. Una excepción en una vista añade una incidencia con el tipo de excepción, el mecanismo `django.middleware` y `handled: false`.

La incidencia no conserva el mensaje de la excepción. Para conservarlo, registra el error con `logger.exception()`, como hace la vista `pay`.

Un log escrito durante una solicitud lleva el ID de traza de esa solicitud. `Http404` y las demás excepciones 4xx crean un span con su estado y ninguna incidencia.

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

## Preguntas frecuentes

### ¿Por qué Django no registra los errores 500?

Con `DEBUG = False`, la configuración por defecto envía los errores de `django.request` solo a `mail_admins`, que los manda por correo a los `ADMINS`. Añade un dict `LOGGING` con un handler de consola en el logger raíz para imprimirlos.

### ¿Cómo cambio el nivel de log en Django?

Define `level` en el logger raíz dentro de `LOGGING`. Léelo de una variable de entorno como `LOG_LEVEL` para cambiarlo sin tocar el código.

### ¿Cómo registro una excepción con su traza de pila en Django?

Llama a `logger.exception()` dentro de `except`. Registra en `ERROR` y añade la traza de pila.

### ¿Qué hace disable_existing_loggers?

Con `True`, los loggers propios de Django se detienen cuando se aplica tu `LOGGING`, así que `django.request` no imprime nada. Déjalo en `False`.

## Ve cada error de Django con su solicitud

logbrew-django registra cada error no controlado de una vista como una incidencia con el nombre de su ruta, y envía tus logs con la traza de su solicitud. Empieza con el generoso plan gratuito, sin tarjeta.

[Empezar gratis](https://logbrew.co/es)

## Fuentes

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

## Más guías para agentes, Python, Node.js y React

- [Añade un servidor MCP a Claude Code y Codex](https://logbrew.co/es/guides/mcp-server-claude-code-codex)
- [Usa AGENTS.md en Claude Code y Codex](https://logbrew.co/es/guides/agents-md)
- [Soluciona el error 529 overloaded y el error 429 de rate limit en Claude](https://logbrew.co/es/guides/claude-overloaded-rate-limit-error)
- [Configura el módulo Python logging con los niveles de log correctos y captura de excepciones](https://logbrew.co/es/guides/python-logging)
- [Structured logging con un formato de log y niveles que puedes buscar por campo](https://logbrew.co/es/guides/structured-logging)
- [Configura el logging en Node.js con Pino o Winston sin perder ningún error](https://logbrew.co/es/guides/node-logging)
- [Configura el logging de FastAPI y maneja los errores sin perder la traza de pila](https://logbrew.co/es/guides/fastapi-logging)
- [Añade un error boundary de React y registra los errores que se le escapan](https://logbrew.co/es/guides/react-error-boundary)
- [Trace ID vs span ID, decodificados de una cabecera traceparent real](https://logbrew.co/es/guides/trace-id)
- [Guías de errores, logs, trazas, métricas y versiones](https://logbrew.co/es/guides)
