---
title: "Effektives Fehler-Tracking in Django mit Sentry"
description: "Erfahre, wie du mit Sentry Fehler in Django-Anwendungen effektiv überwachst und behebst. Profitiere von Echtzeit-Fehlermeldungen und detaillierten Analysen für eine stabile Webentwicklung."
canonical_url: "https://www.blueshoe.de/blog/fehler-tracking-django-sentry/"
---
Fehler in der produktiven Umgebungen passieren. Und das Allerschlimmste ist, wenn man erst durch die Nutzer davon erfährt. Genau hier kommt Sentry ins Spiel. Ein Blick ins Dashboard reicht und du siehst, was gerade passiert: Ein übersichtliches Stacktrace, der betroffene Benutzer und wie oft der Fehler schon aufgetreten ist.
## Warum du Sentry unbedingt brauchst
Fehler in Live-Umgebungen können teuer werden. Wenn du dich auf E-Mails deiner Nutzer:innen verlässt, ist es oft schon zu spät. [Sentry](https://sentry.io)) bringt dir Echtzeit-Fehlermeldungen direkt ins Dashboard – inkl. User, Stacktrace und sogar Umgebung (Staging, Prod etc.).
## Schnellstart: So integrierst du Sentry in Django
### 1. SDK installieren
```bash
pip install --upgrade sentry-sdk
```
### 2. Projekt bei Sentry.io erstellen
Melde dich auf sentry.io an oder logge dich ein. Erstelle dort ein neues Projekt und wähle „Django“ als Plattform. Sentry generiert dir daraufhin automatisch einen DSN, das ist eine eindeutige URL, über die deine Anwendung Fehler an das richtige Projekt bei Sentry sendet.
Beispiel-DSN:
```bash
https://examplePublicKey@o0.ingest.sentry.io/0
```
Diesen DSN kopierst du und bindest ihn im nächsten Schritt in deine Django-App ein.
### 3. In `settings.py` integrieren
Integriere den DSN und die grundlegenden Einstellungen für Sentry in dein Projekt. Wichtig dabei sind drei Parameter:
- **dsn**: Verbindet deine App mit deinem Projekt bei Sentry.
- **traces_sample_rate**: Gibt an, wie viel Prozent der Performance-Daten (z. B. Langsamkeit von Views) gesammelt werden sollen. Bei `1.0` werden alle Daten erfasst. Für produktive Systeme sind Werte wie `0.2` üblich, um Datenmenge und Kosten zu reduzieren.
- **send_default_pii**: Aktiviert das Mitsenden personenbezogener Daten (z. B. eingeloggte User), damit du besser nachvollziehen kannst, wen ein Fehler betrifft.
```python
import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration
sentry_sdk.init(
dsn=SENTRY_DSN,
traces_sample_rate=0.1,
profiles_sample_rate=0.1,
environment=SENTRY_ENV,
default_integrations=False,
release=VERSION,
integrations=[
DjangoIntegration()
],
send_default_pii=True
)
```
### Environments trennen
Gerade bei größeren Projekten willst du unterscheiden können, ob ein Fehler in deiner Entwicklungs-, Staging- oder Produktionsumgebung auftritt. Sonst besteht die Gefahr, dass du bei Tests generierte Fehlermeldungen für Live-Probleme hältst.
Die environment-Angabe im Sentry-Setup hilft dir dabei, das sauber zu trennen:
```python
ENVIRONMENT = os.getenv("ENVIRONMENT", "development")
```
Du kannst diesen Wert z.B. über Umgebungsvariablen pro Server setzen. Im Sentry-Dashboard kannst du später nach Environment filtern oder gezielte Alerts nur für Production-Fehler anlegen.
## Manuelles Logging
Um deinen ersten Fehler zu testen, kannst du Sentry auch manuell ansprechen. Das ist besonders hilfreich, wenn du einen Fehler in einem bestimmten Kontext erfassen willst. Zum Beispiel, wenn du einen Fehler in einer bestimmten Funktion oder bei einem bestimmten Nutzer erfassen möchtest.
```python
try:
...
except Exception as e:
sentry_sdk.capture_exception(e)
```
Damit wäre die Einrichtung von Sentry in Django abgeschlossen. Du kannst jetzt Fehler in deiner App überwachen und bekommst sofort eine Benachrichtigung, wenn etwas schiefgeht. Super! Nun noch ein paar Tipps, wie du Sentry optimal nutzen kannst.
Wir können das Error-Tracking auch in Deiner Django App verbessern
## Best Practices für eine saubere Fehlerüberwachung
Einmal eingerichtet, kannst du mit ein paar Tipps das Beste aus Sentry herausholen:
### 1. Konsequent Environments nutzen
Ordne alle Fehler sauber nach `production`, `staging` oder `development`. So kannst du gezielt nach Problemen im Live-System suchen – und behältst bei Tests die Übersicht.
### 2. Release-Tags verwenden
Wenn du regelmäßig neue Versionen deployst, solltest du `release="myapp@1.2.3"` setzen. Damit kannst du erkennen, ob ein Fehler erst seit einer bestimmten Version auftritt. Praktisch bei Regressions oder Hotfixes.
### 3. Nutzerkontext aktivieren
Sentry kann dir sagen, welcher eingeloggte Nutzer betroffen war. Das hilft enorm beim Nachvollziehen und Debuggen.
```python
set_user({"email": user.email})
```
### 4. Fehler gezielt ignorieren
Nicht jede Exception ist kritisch. Du kannst Regeln in Sentry anlegen, um z.B. 404-Fehler oder bestimmte Warnungen auszublenden. So bleibt dein Alert-Feed übersichtlich.
### 5. Alert-Regeln definieren
Setze Alerts z. B. bei mehr als 10 Fehlern in 5 Minuten oder wenn eine bestimmte Umgebung betroffen ist. Diese Regeln kannst du per Slack, E-Mail oder Webhook triggern lassen.
## Das Sentry-Dashboard verstehen
- Das Dashboard ist dein zentraler Einstiegspunkt. Es zeigt dir sofort:
- Neue und häufige Fehler
- Welche Releases und Environments betroffen sind
- Den Zeitverlauf und Trends von Fehlern
Hier erhältst du eine Übersicht über alle Fehler, die in deiner App aufgetreten sind. Du kannst sie nach Schweregrad, Häufigkeit und Umgebung filtern.
---
## Fehler und Issues im Detail
Klickst du im Dashboard auf einen Fehler, bekommst du eine detaillierte Übersicht:
- Stacktrace mit Codezeilen
- Kontext der Anfrage (Header, URL, etc.)
- User-Daten (falls aktiviert)
- Link zum betroffenen Release
Sentry gruppiert identische Fehler automatisch, sodass du nicht jeden einzelnen Vorfall manuell prüfen musst.
Hier siehst du auf einen Blick: Was ist kritisch? Was wurde zuletzt gesehen? Wie viele Nutzer:innen sind betroffen?
---
## Fazit
Mit Sentry bist du im Fehlerfall immer sofort informiert – und kannst handeln, bevor es eskaliert. Einrichten lohnt sich, nicht nur in der Produktion, sondern auch in Staging & Dev.
## Sitemap
See the full [sitemap](/sitemap.md) for all pages.