---
title: "FastAPI-Logging einrichten und Fehler behandeln, ohne den Traceback zu verlieren"
description: "FastAPI gab kein info-Log aus, bis wir Logging konfiguriert hatten, und nur uvicorn zeigte den Traceback eines 500-Fehlers. Hier sind die Einrichtung, die Fehler-Handler und LogBrew, getestet mit FastAPI 0.165."
canonical: "https://logbrew.co/de/guides/fastapi-logging"
last_updated: "2026-11-21"
---

# FastAPI-Logging einrichten und Fehler behandeln, ohne den Traceback zu verlieren

FastAPI gab kein `info`-Log aus, bis wir Logging konfiguriert hatten, und nur uvicorn zeigte den Traceback eines 500-Fehlers. Hier sind die Einrichtung, die Fehler-Handler und LogBrew, getestet mit FastAPI 0.165.

Getestet am 21. November 2026 mit Python 3.13.5, FastAPI 0.165.0, uvicorn 0.54.0, logbrew-sdk 0.1.29, logbrew-fastapi 0.1.14 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/fastapi-logging

## Was FastAPI ohne Einrichtung ausgibt und was LogBrew bekommt

| Ereignis | Ausgabe ohne Einrichtung | Issue oder Log in LogBrew |
| --- | --- | --- |
| `logger.debug()` | Verworfen | Verworfen bei `INFO` |
| `logger.info()` | Verworfen | `info`-Log |
| `logger.warning()` | Nur die Nachricht | `warning`-Log |
| `ValueError` in einer Route | Traceback von uvicorn | Issue |
| Pfadwert keine Zahl, 422 | Nur die Zugriffszeile | Span, kein Issue |
| `HTTPException`, 404 | Nur die Zugriffszeile | Span, kein Issue |

6 Ereignisse in FastAPI 0.165.0 unter uvicorn 0.54.0, dann dieselben mit `basicConfig()` und logbrew-fastapi 0.1.14.

## Aus einer FastAPI-App loggen

### Sieh dir an, was FastAPI ohne Einrichtung ausgibt

Unsere App hat 1 Logger namens `taproom` und 3 Routen. Wir haben sie mit `uvicorn main:app` gestartet. uvicorn richtet nur seine eigenen Logger ein, deshalb gab Python `warning` und höher als bloßen Text aus und verwarf `debug` und `info`.

```bash
import logging

from fastapi import FastAPI, HTTPException

app = FastAPI()
logger = logging.getLogger("taproom")


@app.get("/taps/{tap}")
def pour(tap: str):
    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 {"tap": tap}


@app.get("/kegs/{keg_id}")
def keg(keg_id: int):
    raise ValueError(f"keg {keg_id} is empty")


@app.get("/missing")
def missing():
    raise HTTPException(status_code=404, detail="no such tap")
```

Ausgabe

```text
keg below 10%
keg empty
cooler offline
INFO:     127.0.0.1:51421 - "GET /taps/ipa HTTP/1.1" 200 OK
```

### basicConfig() aufrufen, bevor du die App erstellst

`logging.basicConfig()` gibt dem Root-Logger ein Level und ein Format. Die `taproom`-Zeilen zeigen jetzt ihr Level, und `info` erscheint. uvicorn behält sein eigenes Format.

```bash
import logging
import os

from fastapi import FastAPI, HTTPException

logging.basicConfig(
    level=os.environ.get("LOG_LEVEL", "INFO"),
    format="%(levelname)s %(name)s %(message)s",
)

app = FastAPI()
logger = logging.getLogger("taproom")
```

Ausgabe

```text
INFO taproom tap ipa opened
WARNING taproom keg below 10%
ERROR taproom keg empty
CRITICAL taproom cooler offline
INFO:     127.0.0.1:51428 - "GET /taps/ipa HTTP/1.1" 200 OK
```

### Das Level aus der Umgebung lesen

Der Aufruf von `basicConfig()` oben liest `LOG_LEVEL`. Starte uvicorn mit `LOG_LEVEL=DEBUG`, und die `debug`-Zeile erscheint, ohne dass du Code änderst.

```bash
LOG_LEVEL=DEBUG uvicorn main:app
```

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
INFO:     127.0.0.1:51442 - "GET /taps/ipa HTTP/1.1" 200 OK
```

## Fehler in FastAPI behandeln

### Sieh dir an, was eine unbehandelte Exception ausgibt

Der Client bekam `Internal Server Error` mit Status 500. uvicorn gab `Exception in ASGI application` und den Traceback aus. Der Pfad `/kegs/abc` lieferte 422 mit einer `detail`-Liste, und `HTTPException` lieferte ihr `detail` mit 404. Beide gaben keinen Traceback aus. Wir haben 27 Frames von uvicorn, Starlette und FastAPI gekürzt.

```bash
curl localhost:8000/kegs/7
curl localhost:8000/kegs/abc
curl localhost:8000/missing
```

Ausgabe

```text
INFO:     127.0.0.1:51422 - "GET /kegs/7 HTTP/1.1" 500 Internal Server Error
ERROR:    Exception in ASGI application
Traceback (most recent call last):
  …
  File "main.py", line 21, in keg
    raise ValueError(f"keg {keg_id} is empty")
ValueError: keg 7 is empty
INFO:     127.0.0.1:51423 - "GET /kegs/abc HTTP/1.1" 422 Unprocessable Content
INFO:     127.0.0.1:51424 - "GET /missing HTTP/1.1" 404 Not Found
```

### Einen Exception-Handler für Exception hinzufügen

Der Handler loggt den Fehler und gibt dein eigenes JSON zurück, und der Client bekam `{"error":"internal"}`. uvicorn gab den Traceback trotzdem aus, weil Starlette die Exception erneut auslöst, nachdem es deine Antwort gesendet hat. Der Traceback erschien also 2 Mal.

```bash
from fastapi import Request
from fastapi.responses import JSONResponse


@app.exception_handler(Exception)
async def on_error(request: Request, exc: Exception):
    logger.exception("request failed")
    return JSONResponse({"error": "internal"}, status_code=500)
```

Ausgabe

```text
ERROR taproom request failed
Traceback (most recent call last):
  …
  File "main.py", line 34, in keg
    raise ValueError(f"keg {keg_id} is empty")
ValueError: keg 7 is empty
INFO:     127.0.0.1:51436 - "GET /kegs/7 HTTP/1.1" 500 Internal Server Error
ERROR:    Exception in ASGI application
Traceback (most recent call last):
  …
  File "main.py", line 34, in keg
    raise ValueError(f"keg {keg_id} is empty")
ValueError: keg 7 is empty
```

## FastAPI-Logs und -Fehler an LogBrew senden

### Das Paket installieren

`logbrew-fastapi` installiert auch `logbrew-sdk`. Nimm einen Server-Schlüssel deines LogBrew-Projekts.

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

### init_logbrew() nach dem Erstellen der App aufrufen

`init_logbrew()` legt für jede Anfrage einen Span an und speichert jeden unbehandelten Fehler als Issue. `logbrew.logging_handler` sendet die Einträge deines Loggers. Wir haben an einen lokalen LogBrew-Server gesendet, deshalb hat unsere Kopie zusätzlich einen `transport` übergeben.

```bash
import logging
import os

from fastapi import FastAPI, HTTPException
from logbrew_fastapi import init_logbrew

logging.basicConfig(
    level=os.environ.get("LOG_LEVEL", "INFO"),
    format="%(levelname)s %(name)s %(message)s",
)

app = FastAPI()
logbrew = init_logbrew(
    app, api_key=os.environ["LOGBREW_API_KEY"], service_name="taproom"
)
logger = logging.getLogger("taproom")
logger.addHandler(logbrew.logging_handler)
```

### Issue und Logs zurücklesen

Wir haben dieselben 4 Anfragen erneut gesendet und das Projekt mit einem Leseschlüssel gelesen. Aus dem 500-Fehler wurde 1 Issue mit dem Namen des Routen-Templates. Die 4 Logs von `/taps/ipa` teilen sich 1 Trace-ID. Der 422 und der 404 erzeugten kein Issue.

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

Ausgabe

```text
Issues (1)
- b100cd3d-f932-57c7-8f23-38067f1c87d7 unresolved error priority=medium GET /kegs/{keg_id} failed occurrences=1 users=unknown last_seen=2026-11-21T06:44:18.663Z service=taproom trace=6b642297fc5d4259b1f17f2bf83b1abb assignee=unassigned [unversioned / production]
Logs (4)
- error keg empty service=taproom trace=fcc0eaf7997f4e0796c0b76e0678b455 [unversioned / production]
- warning keg below 10% service=taproom trace=fcc0eaf7997f4e0796c0b76e0678b455 [unversioned / production]
- critical cooler offline service=taproom trace=fcc0eaf7997f4e0796c0b76e0678b455 [unversioned / production]
- info tap ipa opened service=taproom trace=fcc0eaf7997f4e0796c0b76e0678b455 [unversioned / production]
```

### Prüfen, was das Issue behält

Das Issue behält den Exception-Typ, die Route und 21 Stack-Frames, aber nicht die Nachricht. LogBrew schreibt dort `Unhandled exception`.

```bash
logbrew issues --since 1h --json | jq '.[0].attributes | {
  message, exception,
  route: .metadata.routeTemplate,
  frames: (.stackFrames | length)
}'
```

Ausgabe

```text
{
  "message": "Unhandled exception",
  "exception": {
    "mechanism": {
      "handled": false,
      "type": "fastapi.middleware"
    },
    "type": "ValueError"
  },
  "route": "/kegs/{keg_id}",
  "frames": 21
}
```

### Die Nachricht mit deinem Exception-Handler behalten

Mit dem Exception-Handler von oben speicherte LogBrew das Issue weiterhin, und das Log `request failed` behielt die Nachricht, die dem Issue fehlt.

```bash
logbrew read logs --since 1h --severity error \
  --search "request failed" --json | jq '.[0] | {
  message,
  exceptionName: .attributes.metadata.exceptionName,
  exceptionMessage: .attributes.metadata.exceptionMessage
}'
```

Ausgabe

```text
{
  "message": "request failed",
  "exceptionName": "ValueError",
  "exceptionMessage": "keg 7 is empty"
}
```

## Was wir beim Testen gesehen haben

Wir haben 1 App mit FastAPI 0.165.0 und uvicorn 0.54.0 auf Python 3.13.5 laufen lassen, jede Route mit curl aufgerufen und die Serverausgabe gelesen. Danach haben wir logbrew-fastapi 0.1.14 ergänzt und gelesen, was ein lokaler LogBrew-Server gespeichert hat.

uvicorn gab den Traceback jeder unbehandelten Exception aus, mit oder ohne Handler. Fehler, die FastAPI in eine Antwort umwandelt, etwa ein 422 oder eine `HTTPException`, erzeugten nur die Zugriffszeile.

| Anfrage | `status_code` | Traceback ausgegeben | Issue in LogBrew |
| --- | --- | --- | --- |
| `/kegs/7` | `500` | Ja | Ja |
| `/kegs/abc` | `422` | Nein | Nein |
| `/missing` | `404` | Nein | Nein |

## FastAPI-Log-Level und die Ausgabe von uvicorn

Python hat 5 Level, `DEBUG`, `INFO`, `WARNING`, `ERROR` und `CRITICAL`. Ohne Einrichtung verwirft der Root-Logger jeden Eintrag unter `WARNING`.

uvicorn gibt seine Zugriffszeilen und Fehler im eigenen Format aus, und `basicConfig()` hat daran nichts geändert. LogBrew behält `warning`, `error` und `critical` unverändert und speichert `DEBUG` und `INFO` als `info`.

|  | Ohne Einrichtung | `basicConfig()` | LogBrew |
| --- | --- | --- | --- |
| `logger.debug()` | Nein | Mit `LOG_LEVEL=DEBUG` | Nein |
| `logger.info()` | Nein | Ja | `info` |
| `logger.warning()` | Ja | Ja | `warning` |
| `logger.error()` | Ja | Ja | `error` |
| `logger.critical()` | Ja | Ja | `critical` |

## Was LogBrew speichert

`init_logbrew()` speichert 1 Span pro Anfrage, benannt nach dem Routen-Template, etwa `GET /kegs/{keg_id}`. Eine unbehandelte Exception erzeugt ein Issue mit dem Exception-Typ, dem Mechanismus `fastapi.middleware`, `handled: false` und den Stack-Frames.

Ein Log, das während einer Anfrage entsteht, trägt die Trace-ID dieser Anfrage. Die Anfragen mit 422 und 404 erzeugten Spans ohne Fehler.

- `init_logbrew()`
  - Issue: `GET /kegs/{keg_id} failed`
  - `exception.type`: `ValueError`
  - `mechanism`: `fastapi.middleware`
  - `handled`: `false`
  - Stackframes: 21
- `logbrew.logging_handler`
  - Meldung: `request failed`
  - `exceptionName`: `ValueError`
  - `exceptionMessage`: `keg 7 is empty`

## Häufige Fragen

### Wie richte ich Logging in FastAPI ein?

Ruf `logging.basicConfig()` einmal oben in `main.py` auf und nutze dann `logging.getLogger()` in jedem Modul. Ohne Einrichtung verwirft Python `info` und `debug`.

### Wie behandle ich alle Exceptions in FastAPI?

Füge `@app.exception_handler(Exception)` hinzu und gib deine eigene Antwort zurück. Der Client bekommt deine Antwort, und uvicorn gibt den Traceback trotzdem aus.

### Warum gibt FastAPI 422 zurück?

Ein Wert in Pfad, Query oder Body passte nicht zu seinem Typ. `/kegs/abc` fiel durch die Prüfung `keg_id: int`, deshalb lieferte FastAPI die `detail`-Liste mit Status 422.

### Was bedeutet Exception in ASGI application?

Eine Exception hat deine Route verlassen, und kein Handler hat sie abgefangen. uvicorn loggt sie mit Traceback, und der Client bekommt `Internal Server Error` mit Status 500.

## Jeden FastAPI-Fehler mit seiner Route sehen

logbrew-fastapi speichert jeden unbehandelten Fehler als Issue mit dem Namen seines Routen-Templates 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

- [FastAPI docs, Install custom exception handlers](https://fastapi.tiangolo.com/tutorial/handling-errors/#install-custom-exception-handlers)
- [FastAPI docs, Use HTTPException](https://fastapi.tiangolo.com/tutorial/handling-errors/#use-httpexception)
- [fastapi/fastapi#14071](https://github.com/fastapi/fastapi/discussions/14071)

## 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)
- [Django-Logging einrichten und den Traceback jedes 500-Fehlers behalten](https://logbrew.co/de/guides/django-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)
