---
title: "Django-Logging einrichten und den Traceback jedes 500-Fehlers behalten"
description: "Mit DEBUG = False und ohne LOGGING gab Django für einen 500-Fehler keinen Traceback aus. Hier findest du das Django-Logging mit LOGGING, die Log-Level und den Weg der Fehler zu LogBrew, getestet mit Django 6.1."
canonical: "https://logbrew.co/de/guides/django-logging"
last_updated: "2026-11-21"
---

# Django-Logging einrichten und den Traceback jedes 500-Fehlers behalten

Mit `DEBUG = False` und ohne `LOGGING` gab Django für einen 500-Fehler keinen Traceback aus. Hier findest du das Django-Logging mit `LOGGING`, die Log-Level und den Weg der Fehler zu LogBrew, getestet mit Django 6.1.

Getestet am 21. November 2026 mit Python 3.13.5, Django 6.1.3, logbrew-sdk 0.1.29, logbrew-django 0.1.12 und logbrew CLI 0.1.96

Von [Furkan Erday](https://github.com/furkanerday). Furkan Erday hat LogBrew gegründet. Er entwickelt LogBrew jeden Tag mit Claude Code und Codex.

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

## Was Django ohne `LOGGING` ausgibt und was LogBrew bekommt

| Ereignis | Ausgabe ohne `LOGGING` | Issue oder Log in LogBrew |
| --- | --- | --- |
| `logger.debug()` | Verworfen | Verworfen bei `INFO` |
| `logger.info()` | Verworfen | `info`-Log |
| `logger.warning()` | Nur die Nachricht | `warning`-Log |
| `logger.exception()` | Nachricht und Traceback | Log mit der Exception |
| `ValueError` in einer View | Nur die Zugriffszeile | Issue |
| `Http404` | Nur die Zugriffszeile | Span, kein Issue |

6 Ereignisse in Django 6.1.3 mit `DEBUG = False`, dann dieselben mit unserem `LOGGING`-Dict und logbrew-django 0.1.12.

## Django-Logging konfigurieren

### Sieh dir an, was Django ohne LOGGING ausgibt

Unsere App hat 1 Logger namens `taproom` und 4 Views. Mit `DEBUG = False` und ohne `LOGGING` gab Django `warning` und höher als bloßen Text aus und verwarf `debug` und `info`. Der 500-Fehler erschien nur als Zugriffszeile, ohne Traceback.

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

Ausgabe

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

### Ein LOGGING-Dict in settings.py anlegen

Leite den Root-Logger auf die Konsole und lass `disable_existing_loggers` auf `False`, damit Djangos eigene Logger aktiv bleiben. Jetzt gab `django.request` den 500-Fehler mit Traceback auf `ERROR` aus und den 404 auf `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"),
    },
}
```

Ausgabe

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

### Das Level aus der Umgebung lesen

Das `LOGGING`-Dict oben liest `LOG_LEVEL`. Starte den Server mit `LOG_LEVEL=DEBUG`, und die `debug`-Zeile erscheint, ohne dass du Code änderst.

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

Ausgabe

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

### Eine abgefangene Exception mit logger.exception() loggen

In `except` loggt `logger.exception()` auf `ERROR` und hängt den Traceback an. Unsere View `pay` gab außerdem eine 402-Antwort zurück, deshalb loggte `django.request` `Payment Required` auf `WARNING`.

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

Ausgabe

```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 und -Fehler an LogBrew senden

### Die Pakete installieren

`logbrew-django` legt für jede Anfrage einen Span an und speichert jeden unbehandelten Fehler einer View als Issue. `logbrew-sdk` enthält den Client und den Logging-Handler. Nimm einen Server-Schlüssel deines LogBrew-Projekts.

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

### Middleware und Handler in settings.py eintragen

Setz diesen Code hinter `MIDDLEWARE` und `LOGGING`. `LogBrewDjangoMiddleware` muss in `MIDDLEWARE` an erster Stelle stehen. `LogBrewLoggingHandler` sendet jeden Eintrag des Loggers `taproom`. Wir haben an einen lokalen LogBrew-Server gesendet, deshalb hat unsere Kopie `endpoint=` an `HttpTransport()` übergeben.

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

### Issue und Logs zurücklesen

Wir haben die 4 Views erneut aufgerufen und das Projekt mit einem Leseschlüssel gelesen. Aus dem 500-Fehler wurde 1 Issue mit dem Namen der Route. Die `taproom`-Logs behielten ihr Level, und `debug` fehlte, weil das Root-Level `INFO` war. Der 404 erzeugte kein Issue.

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

Ausgabe

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

### Prüfen, was Issue und Log behalten

Das Issue behält den Exception-Typ und die Route, aber nicht die Nachricht. LogBrew schreibt dort `Unhandled exception`. Das Log aus `logger.exception()` behält Name und Nachricht der Exception, die Datei, die Funktion und die Zeile.

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

Ausgabe

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

## Was wir beim Testen gesehen haben

Wir haben 1 App mit Django 6.1.3 auf Python 3.13.5 mit `runserver` und `DEBUG = False` laufen lassen, 4 Views mit curl aufgerufen und die Serverausgabe gelesen. Danach haben wir logbrew-django 0.1.12 ergänzt und gelesen, was ein lokaler LogBrew-Server gespeichert hat.

Mit `DEBUG = True` und ohne `LOGGING` gab Django den Traceback des 500-Fehlers ebenfalls aus. Eine App, die in der Entwicklung Tracebacks zeigt, zeigt in Produktion also womöglich keinen.

|  | Ohne `LOGGING` | Mit `LOGGING` |
| --- | --- | --- |
| `logger.debug()` | Nein | Mit `LOG_LEVEL=DEBUG` |
| `logger.info()` | Nein | Ja |
| `logger.warning()` | Ja | Ja |
| Traceback des 500-Fehlers | Nein | Ja |
| Zeile für den 404 | Nein | Ja |

## Django-Log-Level und der Logger django.request

Django nutzt die 5 Level von Python, `DEBUG`, `INFO`, `WARNING`, `ERROR` und `CRITICAL`. Das Root-Level in `LOGGING` verwirft jeden Eintrag darunter.

`django.request` loggt eine 5xx-Antwort auf `ERROR` und eine 4xx-Antwort auf `WARNING`. Nur der 500 aus einer Exception kam mit Traceback.

LogBrew behält `warning`, `error` und `critical` unverändert und speichert `DEBUG` und `INFO` als `info`.

| Antwort | `django.request` | Traceback |
| --- | --- | --- |
| `500` | `ERROR` | Ja |
| `404` | `WARNING` | Nein |
| `402` | `WARNING` | Nein |

## Was LogBrew speichert

Die Middleware speichert 1 Span pro Anfrage, benannt nach dem Routen-Template, etwa `GET /kegs/<int:keg_id>/`. Eine Exception in einer View erzeugt ein Issue mit dem Exception-Typ, dem Mechanismus `django.middleware` und `handled: false`.

Das Issue behält die Nachricht der Exception nicht. Damit sie erhalten bleibt, logge den Fehler mit `logger.exception()`, so wie die View `pay`.

Ein Log, das während einer Anfrage entsteht, trägt die Trace-ID dieser Anfrage. `Http404` und die anderen 4xx-Exceptions erzeugen einen Span mit ihrem Status und kein Issue.

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

## Häufige Fragen

### Warum loggt Django keine 500-Fehler?

Mit `DEBUG = False` schickt die Standardeinrichtung Fehler von `django.request` nur an `mail_admins`, und das mailt an die `ADMINS`. Füge ein `LOGGING`-Dict mit einem Konsolen-Handler am Root-Logger hinzu, um sie auszugeben.

### Wie setze ich das Log-Level in Django?

Setz `level` am Root-Logger in `LOGGING`. Lies den Wert aus einer Umgebungsvariable wie `LOG_LEVEL`, dann änderst du ihn ohne Codeänderung.

### Wie logge ich in Django eine Exception mit Traceback?

Ruf `logger.exception()` in `except` auf. Es loggt auf `ERROR` und hängt den Traceback an.

### Was bewirkt disable_existing_loggers?

Mit `True` verstummen Djangos eigene Logger, sobald dein `LOGGING` greift, und `django.request` gibt nichts mehr aus. Lass den Wert auf `False`.

## Jeden Django-Fehler mit seiner Anfrage sehen

logbrew-django speichert jeden unbehandelten Fehler einer View als Issue mit dem Namen seiner Route und sendet deine Logs mit dem Trace ihrer Anfrage. Starte mit dem großzügigen kostenlosen Plan, ohne Kreditkarte.

[Kostenlos starten](https://logbrew.co/de)

## Quellen

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

## Weitere Anleitungen für Agenten, Python, Node.js und React

- [MCP-Server in Claude Code und Codex hinzufügen](https://logbrew.co/de/guides/mcp-server-claude-code-codex)
- [AGENTS.md in Claude Code und Codex nutzen](https://logbrew.co/de/guides/agents-md)
- [Claude-Fehler 529 overloaded und 429 Rate Limit beheben](https://logbrew.co/de/guides/claude-overloaded-rate-limit-error)
- [Python-Logging einrichten mit den richtigen Log-Leveln und Exception-Erfassung](https://logbrew.co/de/guides/python-logging)
- [Structured Logging mit Log-Format und Log-Leveln, die du nach Feld durchsuchst](https://logbrew.co/de/guides/structured-logging)
- [Node.js-Logging mit Pino oder Winston einrichten und keinen Fehler verlieren](https://logbrew.co/de/guides/node-logging)
- [FastAPI-Logging einrichten und Fehler behandeln, ohne den Traceback zu verlieren](https://logbrew.co/de/guides/fastapi-logging)
- [Eine React Error Boundary bauen und die Fehler loggen, die sie verpasst](https://logbrew.co/de/guides/react-error-boundary)
- [Trace-ID vs. Span-ID, an einem echten traceparent-Header erklärt](https://logbrew.co/de/guides/trace-id)
- [Anleitungen zu Fehlern, Logs, Traces, Metriken und Releases](https://logbrew.co/de/guides)
