---
title: "Configurez le logging FastAPI et gérez les erreurs sans perdre la stack trace"
description: "FastAPI n’a écrit aucun log info avant que nous configurions le logging, et seul uvicorn a écrit la stack trace d’une erreur 500. Voici la configuration, les handlers d’erreurs et LogBrew, testés sur FastAPI 0.165."
canonical: "https://logbrew.co/fr/guides/fastapi-logging"
last_updated: "2026-11-21"
---

# Configurez le logging FastAPI et gérez les erreurs sans perdre la stack trace

FastAPI n’a écrit aucun log `info` avant que nous configurions le logging, et seul uvicorn a écrit la stack trace d’une erreur 500. Voici la configuration, les handlers d’erreurs et LogBrew, testés sur FastAPI 0.165.

Testé le 21 novembre 2026 avec Python 3.13.5, FastAPI 0.165.0, uvicorn 0.54.0, logbrew-sdk 0.1.29, logbrew-fastapi 0.1.14 et logbrew CLI 0.1.96

Par [Furkan Erday](https://github.com/furkanerday). Furkan Erday est le fondateur de LogBrew. Il développe LogBrew avec Claude Code et Codex tous les jours.

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

## Ce que FastAPI écrit sans configuration, et ce que LogBrew reçoit

| Événement | Écrit sans configuration | Problème ou log dans LogBrew |
| --- | --- | --- |
| `logger.debug()` | Ignoré | Ignoré au niveau `INFO` |
| `logger.info()` | Ignoré | Log `info` |
| `logger.warning()` | Message seul | Log `warning` |
| `ValueError` dans une route | Stack trace d’uvicorn | Problème |
| Valeur de chemin non numérique, 422 | Ligne d’accès seule | Span, sans problème |
| `HTTPException`, 404 | Ligne d’accès seule | Span, sans problème |

6 événements dans FastAPI 0.165.0 sous uvicorn 0.54.0, puis les mêmes avec `basicConfig()` et logbrew-fastapi 0.1.14.

## Logger depuis une application FastAPI

### Voyez ce que FastAPI écrit sans configuration

Notre application a 1 logger nommé `taproom` et 3 routes. Nous l’avons lancée avec `uvicorn main:app`. uvicorn ne configure que ses propres loggers, donc Python a écrit `warning` et au-dessus en texte brut, et a ignoré `debug` et `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")
```

Sortie

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

### Appelez basicConfig() avant de créer l’application

`logging.basicConfig()` donne au logger racine un niveau et un format. Les lignes `taproom` affichent maintenant leur niveau, et `info` apparaît. uvicorn garde son propre 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")
```

Sortie

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

### Lisez le niveau dans l’environnement

L’appel à `basicConfig()` ci-dessus lit `LOG_LEVEL`. Lancez uvicorn avec `LOG_LEVEL=DEBUG` et la ligne `debug` apparaît, sans changer le code.

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

Sortie

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

## Gérer les erreurs dans FastAPI

### Voyez ce qu’écrit une exception non gérée

Le client a reçu `Internal Server Error` avec le statut 500. uvicorn a écrit `Exception in ASGI application` et la stack trace. Le chemin `/kegs/abc` a renvoyé 422 avec une liste `detail`, et `HTTPException` a renvoyé son `detail` avec 404. Aucun des deux n’a écrit de stack trace. Nous avons coupé 27 frames d’uvicorn, de Starlette et de FastAPI.

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

Sortie

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

### Ajoutez un handler d’exceptions pour Exception

Le handler logge l’erreur et renvoie votre propre JSON, et le client a reçu `{"error":"internal"}`. uvicorn a quand même écrit la stack trace, car Starlette relance l’exception après avoir envoyé votre réponse. La stack trace est donc apparue 2 fois.

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

Sortie

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

## Envoyer les logs et les erreurs FastAPI à LogBrew

### Installez le paquet

`logbrew-fastapi` installe aussi `logbrew-sdk`. Utilisez une clé serveur de votre projet LogBrew.

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

### Appelez init_logbrew() après avoir créé l’application

`init_logbrew()` enregistre un span pour chaque requête et chaque erreur non gérée comme un problème. `logbrew.logging_handler` envoie les enregistrements de votre logger. Nous avons envoyé vers un serveur LogBrew local, donc notre copie a aussi passé un `transport`.

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

### Relisez le problème et les logs

Nous avons renvoyé les 4 mêmes requêtes, puis lu le projet avec une clé de lecture. L’erreur 500 est devenue 1 problème nommé d’après le modèle de route. Les 4 logs de `/taps/ipa` partagent 1 ID de trace. Le 422 et le 404 n’ont créé aucun problème.

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

Sortie

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

### Vérifiez ce que garde le problème

Le problème garde le type de l’exception, la route et 21 frames de pile, mais pas le message. LogBrew écrit `Unhandled exception` à sa place.

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

Sortie

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

### Gardez le message avec votre handler d’exceptions

Avec le handler d’exceptions vu plus haut, LogBrew a toujours enregistré le problème, et le log `request failed` a gardé le message que le problème laisse de côté.

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

Sortie

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

## Ce que nous avons constaté en testant

Nous avons lancé 1 application FastAPI 0.165.0 avec uvicorn 0.54.0 sur Python 3.13.5, appelé chaque route avec curl et lu la sortie du serveur. Ensuite, nous avons ajouté logbrew-fastapi 0.1.14 et lu ce qu’un serveur LogBrew local a stocké.

uvicorn a écrit la stack trace de chaque exception non gérée, avec ou sans handler. Les erreurs que FastAPI transforme en réponse, comme un 422 ou une `HTTPException`, n’ont donné que la ligne d’accès.

| Requête | `status_code` | Stack trace écrite | Problème dans LogBrew |
| --- | --- | --- | --- |
| `/kegs/7` | `500` | Oui | Oui |
| `/kegs/abc` | `422` | Non | Non |
| `/missing` | `404` | Non | Non |

## Les niveaux de log FastAPI et la sortie d’uvicorn

Python a 5 niveaux, `DEBUG`, `INFO`, `WARNING`, `ERROR` et `CRITICAL`. Sans configuration, le logger racine ignore chaque enregistrement sous `WARNING`.

uvicorn écrit ses lignes d’accès et ses erreurs dans son propre format, et `basicConfig()` ne les a pas changées. LogBrew garde `warning`, `error` et `critical` tels quels, et stocke `DEBUG` et `INFO` comme `info`.

|  | Sans configuration | `basicConfig()` | LogBrew |
| --- | --- | --- | --- |
| `logger.debug()` | Non | Avec `LOG_LEVEL=DEBUG` | Non |
| `logger.info()` | Non | Oui | `info` |
| `logger.warning()` | Oui | Oui | `warning` |
| `logger.error()` | Oui | Oui | `error` |
| `logger.critical()` | Oui | Oui | `critical` |

## Ce que LogBrew enregistre

`init_logbrew()` enregistre 1 span par requête, nommé d’après le modèle de route, par exemple `GET /kegs/{keg_id}`. Une exception non gérée ajoute un problème avec le type de l’exception, le mécanisme `fastapi.middleware`, `handled: false` et les frames de pile.

Un log écrit pendant une requête porte l’ID de trace de cette requête. Les requêtes 422 et 404 ont créé des spans sans erreur.

- `init_logbrew()`
  - Problème: `GET /kegs/{keg_id} failed`
  - `exception.type`: `ValueError`
  - `mechanism`: `fastapi.middleware`
  - `handled`: `false`
  - Frames de stack trace: 21
- `logbrew.logging_handler`
  - Message: `request failed`
  - `exceptionName`: `ValueError`
  - `exceptionMessage`: `keg 7 is empty`

## Questions fréquentes

### Comment configurer le logging dans FastAPI ?

Appelez `logging.basicConfig()` une seule fois en haut de `main.py`, puis utilisez `logging.getLogger()` dans chaque module. Sans configuration, Python ignore `info` et `debug`.

### Comment gérer toutes les exceptions dans FastAPI ?

Ajoutez `@app.exception_handler(Exception)` et renvoyez votre propre réponse. Le client reçoit votre réponse, et uvicorn écrit quand même la stack trace.

### Pourquoi FastAPI renvoie-t-il 422 ?

Une valeur du chemin, de la query ou du body ne correspondait pas à son type. `/kegs/abc` a échoué au contrôle `keg_id: int`, donc FastAPI a renvoyé la liste `detail` avec le statut 422.

### Que veut dire Exception in ASGI application ?

Une exception est sortie de votre route et aucun handler ne l’a arrêtée. uvicorn la logge avec la stack trace, et le client reçoit `Internal Server Error` avec le statut 500.

## Voyez chaque erreur FastAPI avec sa route

logbrew-fastapi enregistre chaque erreur non gérée comme un problème nommé d’après son modèle de route, et envoie vos logs avec la trace de leur requête. Commencez avec le forfait Free généreux, sans carte bancaire.

[Commencer gratuitement](https://logbrew.co/fr)

## Sources

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

## Autres guides pour les agents, Python, Node.js et React

- [Ajouter un serveur MCP à Claude Code et Codex](https://logbrew.co/fr/guides/mcp-server-claude-code-codex)
- [Utiliser AGENTS.md dans Claude Code et Codex](https://logbrew.co/fr/guides/agents-md)
- [Corriger l’erreur Claude overloaded 529 et l’erreur rate limit 429](https://logbrew.co/fr/guides/claude-overloaded-rate-limit-error)
- [Configurer le module Python logging avec les bons niveaux de log et la capture des exceptions](https://logbrew.co/fr/guides/python-logging)
- [Structured logging avec un format de log et des niveaux que vous cherchez par champ](https://logbrew.co/fr/guides/structured-logging)
- [Configurer le logging Node.js avec Pino ou Winston sans perdre une seule erreur](https://logbrew.co/fr/guides/node-logging)
- [Configurez le logging Django et gardez la stack trace de chaque erreur 500](https://logbrew.co/fr/guides/django-logging)
- [Ajoutez un périmètre d’erreur React et loggez les erreurs qu’il laisse passer](https://logbrew.co/fr/guides/react-error-boundary)
- [Trace ID vs span ID, décodés depuis un vrai en-tête traceparent](https://logbrew.co/fr/guides/trace-id)
- [Guides sur les erreurs, logs, traces, métriques et versions](https://logbrew.co/fr/guides)
