---
title: "Stel FastAPI-logging in en handel fouten af zonder de stacktrace te verliezen"
description: "FastAPI schreef geen info-log tot we logging configureerden, en alleen uvicorn schreef de stacktrace van een 500-fout. Hier lees je de instelling, de foutafhandelaars en LogBrew, getest op FastAPI 0.165."
canonical: "https://logbrew.co/nl/guides/fastapi-logging"
last_updated: "2026-11-21"
---

# Stel FastAPI-logging in en handel fouten af zonder de stacktrace te verliezen

FastAPI schreef geen `info`-log tot we logging configureerden, en alleen uvicorn schreef de stacktrace van een 500-fout. Hier lees je de instelling, de foutafhandelaars en LogBrew, getest op FastAPI 0.165.

Getest op 21 november 2026 met Python 3.13.5, FastAPI 0.165.0, uvicorn 0.54.0, logbrew-sdk 0.1.29, logbrew-fastapi 0.1.14 en logbrew CLI 0.1.96

Door [Furkan Erday](https://github.com/furkanerday). Furkan Erday is de oprichter van LogBrew. Hij bouwt LogBrew elke dag met Claude Code en Codex.

Canonical: https://logbrew.co/nl/guides/fastapi-logging

## Wat FastAPI zonder instelling schrijft, en wat LogBrew krijgt

| Event | Geschreven zonder instelling | Issue of log in LogBrew |
| --- | --- | --- |
| `logger.debug()` | Weggelaten | Weggelaten bij `INFO` |
| `logger.info()` | Weggelaten | `info`-log |
| `logger.warning()` | Alleen het bericht | `warning`-log |
| `ValueError` in een route | Stacktrace van uvicorn | Issue |
| Padwaarde geen getal, 422 | Alleen de toegangsregel | Span, geen issue |
| `HTTPException`, 404 | Alleen de toegangsregel | Span, geen issue |

6 events in FastAPI 0.165.0 onder uvicorn 0.54.0, daarna dezelfde met `basicConfig()` en logbrew-fastapi 0.1.14.

## Loggen vanuit een FastAPI-app

### Bekijk wat FastAPI zonder instelling schrijft

Onze app heeft 1 logger met de naam `taproom` en 3 routes. We startten hem met `uvicorn main:app`. uvicorn stelt alleen zijn eigen loggers in, dus Python schreef `warning` en hoger als kale tekst, en liet `debug` en `info` vallen.

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

Uitvoer

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

### Roep basicConfig() aan voordat je de app maakt

`logging.basicConfig()` geeft de root-logger een niveau en een formaat. De `taproom`-regels tonen nu hun niveau, en `info` verschijnt. uvicorn houdt zijn eigen formaat.

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

Uitvoer

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

### Lees het niveau uit de omgeving

De aanroep van `basicConfig()` hierboven leest `LOG_LEVEL`. Start uvicorn met `LOG_LEVEL=DEBUG` en de `debug`-regel verschijnt, zonder codewijziging.

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

Uitvoer

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

## Fouten afhandelen in FastAPI

### Bekijk wat een onafgehandelde exception schrijft

De client kreeg `Internal Server Error` met status 500. uvicorn schreef `Exception in ASGI application` en de stacktrace. Het pad `/kegs/abc` gaf 422 met een `detail`-lijst, en `HTTPException` gaf zijn `detail` met 404. Geen van beide schreef een stacktrace. We knipten 27 frames van uvicorn, Starlette en FastAPI weg.

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

Uitvoer

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

### Voeg een exception-handler toe voor Exception

De handler logt de fout en geeft je eigen JSON terug, en de client kreeg `{"error":"internal"}`. uvicorn schreef de stacktrace toch, omdat Starlette de exception opnieuw opwerpt nadat het je response heeft verstuurd. De stacktrace verscheen dus 2 keer.

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

Uitvoer

```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 en -fouten naar LogBrew sturen

### Installeer het pakket

`logbrew-fastapi` installeert ook `logbrew-sdk`. Gebruik een serversleutel van je LogBrew-project.

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

### Roep init_logbrew() aan nadat je de app maakt

`init_logbrew()` legt een span vast voor elk request en elke onafgehandelde fout als issue. `logbrew.logging_handler` stuurt de records van je logger. Wij stuurden naar een lokale LogBrew-server, dus onze kopie gaf ook een `transport` mee.

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

### Lees het issue en de logs terug

We stuurden dezelfde 4 requests opnieuw en lazen het project met een leessleutel. De 500-fout werd 1 issue met de naam van het routetemplate. De 4 logs van `/taps/ipa` delen 1 trace-ID. De 422 en de 404 maakten geen issue.

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

Uitvoer

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

### Controleer wat het issue bewaart

Het issue bewaart het type exception, de route en 21 stackframes, maar niet het bericht. LogBrew schrijft daar `Unhandled exception`.

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

Uitvoer

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

### Bewaar het bericht met je exception-handler

Met de exception-handler van hierboven legde LogBrew het issue nog steeds vast, en de log `request failed` bewaarde het bericht dat het issue weglaat.

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

Uitvoer

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

## Wat we zagen in onze test

We draaiden 1 FastAPI 0.165.0-app met uvicorn 0.54.0 op Python 3.13.5, riepen elke route aan met curl en lazen de serveroutput. Daarna voegden we logbrew-fastapi 0.1.14 toe en lazen wat een lokale LogBrew-server opsloeg.

uvicorn schreef de stacktrace van elke onafgehandelde exception, met of zonder handler. Fouten die FastAPI omzet in een response, zoals een 422 of een `HTTPException`, gaven alleen de toegangsregel.

| Request | `status_code` | Stacktrace geschreven | Issue in LogBrew |
| --- | --- | --- | --- |
| `/kegs/7` | `500` | Ja | Ja |
| `/kegs/abc` | `422` | Nee | Nee |
| `/missing` | `404` | Nee | Nee |

## FastAPI-logniveaus en de output van uvicorn

Python heeft 5 niveaus, `DEBUG`, `INFO`, `WARNING`, `ERROR` en `CRITICAL`. Zonder instelling laat de root-logger elk record onder `WARNING` vallen.

uvicorn schrijft zijn toegangsregels en fouten in zijn eigen formaat, en `basicConfig()` veranderde daar niets aan. LogBrew houdt `warning`, `error` en `critical` zoals ze zijn, en slaat `DEBUG` en `INFO` op als `info`.

|  | Zonder instelling | `basicConfig()` | LogBrew |
| --- | --- | --- | --- |
| `logger.debug()` | Nee | Met `LOG_LEVEL=DEBUG` | Nee |
| `logger.info()` | Nee | Ja | `info` |
| `logger.warning()` | Ja | Ja | `warning` |
| `logger.error()` | Ja | Ja | `error` |
| `logger.critical()` | Ja | Ja | `critical` |

## Wat LogBrew vastlegt

`init_logbrew()` legt 1 span per request vast, met de naam van het routetemplate, zoals `GET /kegs/{keg_id}`. Een onafgehandelde exception voegt een issue toe met het type exception, het mechanisme `fastapi.middleware`, `handled: false` en de stackframes.

Een log die tijdens een request ontstaat, draagt de trace-ID van dat request. De requests met 422 en 404 maakten spans zonder fout.

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

## Veelgestelde vragen

### Hoe stel ik logging in FastAPI in?

Roep `logging.basicConfig()` 1 keer aan bovenaan `main.py` en gebruik daarna `logging.getLogger()` in elke module. Zonder instelling laat Python `info` en `debug` vallen.

### Hoe handel ik alle exceptions in FastAPI af?

Voeg `@app.exception_handler(Exception)` toe en geef je eigen response terug. De client krijgt jouw response, en uvicorn schrijft de stacktrace toch.

### Waarom geeft FastAPI 422 terug?

Een waarde in het pad, de query of de body paste niet bij het type. `/kegs/abc` slaagde niet voor de controle `keg_id: int`, dus FastAPI gaf de `detail`-lijst terug met status 422.

### Wat betekent Exception in ASGI application?

Een exception verliet je route en geen handler hield hem tegen. uvicorn logt hem met de stacktrace, en de client krijgt `Internal Server Error` met status 500.

## Zie elke FastAPI-fout met zijn route

logbrew-fastapi legt elke onafgehandelde fout vast als issue met de naam van het routetemplate, en stuurt je logs mee met de trace van hun request. Begin met het ruime gratis abonnement, zonder creditcard.

[Gratis beginnen](https://logbrew.co/nl)

## Bronnen

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

## Meer handleidingen voor agents, Python, Node.js en React

- [Een MCP-server toevoegen aan Claude Code en Codex](https://logbrew.co/nl/guides/mcp-server-claude-code-codex)
- [AGENTS.md gebruiken in Claude Code en Codex](https://logbrew.co/nl/guides/agents-md)
- [Claude overloaded error 529 en rate limit error 429 oplossen](https://logbrew.co/nl/guides/claude-overloaded-rate-limit-error)
- [Python-logging instellen met de juiste logniveaus en exceptions met traceback](https://logbrew.co/nl/guides/python-logging)
- [Structured logging met een logformaat en logniveaus die je per veld doorzoekt](https://logbrew.co/nl/guides/structured-logging)
- [Node.js-logging instellen met Pino of Winston zonder één fout te missen](https://logbrew.co/nl/guides/node-logging)
- [Stel Django-logging in en bewaar de stacktrace van elke 500-fout](https://logbrew.co/nl/guides/django-logging)
- [Voeg een React error boundary toe en log de fouten die hij mist](https://logbrew.co/nl/guides/react-error-boundary)
- [Trace-ID vs span-ID, ontleed in een echte traceparent-header](https://logbrew.co/nl/guides/trace-id)
- [Handleidingen voor fouten, logs, traces, metrics en releases](https://logbrew.co/nl/guides)
