---
title: "Skonfiguruj logowanie w FastAPI i obsłuż błędy bez utraty śladu stosu"
description: "FastAPI nie wypisało żadnego logu info, dopóki nie skonfigurowaliśmy logowania, a ślad stosu błędu 500 wypisał tylko uvicorn. Oto konfiguracja, handlery błędów i LogBrew, przetestowane na FastAPI 0.165."
canonical: "https://logbrew.co/pl/guides/fastapi-logging"
last_updated: "2026-11-21"
---

# Skonfiguruj logowanie w FastAPI i obsłuż błędy bez utraty śladu stosu

FastAPI nie wypisało żadnego logu `info`, dopóki nie skonfigurowaliśmy logowania, a ślad stosu błędu 500 wypisał tylko uvicorn. Oto konfiguracja, handlery błędów i LogBrew, przetestowane na FastAPI 0.165.

Przetestowane 21 listopada 2026 z użyciem Python 3.13.5, FastAPI 0.165.0, uvicorn 0.54.0, logbrew-sdk 0.1.29, logbrew-fastapi 0.1.14 i logbrew CLI 0.1.96

Autor [Furkan Erday](https://github.com/furkanerday). Furkan Erday jest założycielem LogBrew. Codziennie rozwija LogBrew z pomocą Claude Code i Codex.

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

## Co FastAPI wypisuje bez konfiguracji i co dostaje LogBrew

| Zdarzenie | Wypisane bez konfiguracji | Problem albo log w LogBrew |
| --- | --- | --- |
| `logger.debug()` | Pominięte | Pominięte przy `INFO` |
| `logger.info()` | Pominięte | Log `info` |
| `logger.warning()` | Tylko komunikat | Log `warning` |
| `ValueError` w trasie | Ślad stosu z uvicorn | Problem |
| Wartość ścieżki nie jest liczbą, 422 | Tylko linia dostępu | Span, bez problemu |
| `HTTPException`, 404 | Tylko linia dostępu | Span, bez problemu |

6 zdarzeń w FastAPI 0.165.0 pod uvicorn 0.54.0, potem te same z `basicConfig()` i logbrew-fastapi 0.1.14.

## Loguj z aplikacji FastAPI

### Zobacz, co FastAPI wypisuje bez konfiguracji

Nasza aplikacja ma 1 logger o nazwie `taproom` i 3 trasy. Uruchomiliśmy ją przez `uvicorn main:app`. uvicorn konfiguruje tylko własne loggery, więc Python wypisał `warning` i wyższe poziomy jako zwykły tekst, a `debug` i `info` pominął.

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

Wynik

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

### Wywołaj basicConfig() przed utworzeniem aplikacji

`logging.basicConfig()` nadaje głównemu loggerowi poziom i format. Linie `taproom` pokazują teraz swój poziom, a `info` się pojawia. uvicorn zachowuje własny 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")
```

Wynik

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

### Odczytaj poziom ze środowiska

Wywołanie `basicConfig()` powyżej czyta `LOG_LEVEL`. Uruchom uvicorn z `LOG_LEVEL=DEBUG`, a linia `debug` pojawi się bez zmiany kodu.

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

Wynik

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

## Obsługuj błędy w FastAPI

### Zobacz, co wypisuje nieobsłużony wyjątek

Klient dostał `Internal Server Error` ze statusem 500. uvicorn wypisał `Exception in ASGI application` i ślad stosu. Ścieżka `/kegs/abc` zwróciła 422 z listą `detail`, a `HTTPException` zwrócił swoje `detail` z 404. Żaden z nich nie wypisał śladu stosu. Wycięliśmy 27 ramek z uvicorn, Starlette i FastAPI.

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

Wynik

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

### Dodaj handler wyjątków dla Exception

Handler loguje błąd i zwraca Twój własny JSON, a klient dostał `{"error":"internal"}`. uvicorn i tak wypisał ślad stosu, bo Starlette ponownie zgłasza wyjątek po wysłaniu Twojej odpowiedzi. Ślad stosu pojawił się więc 2 razy.

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

Wynik

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

## Wyślij logi i błędy FastAPI do LogBrew

### Zainstaluj pakiet

`logbrew-fastapi` instaluje też `logbrew-sdk`. Użyj klucza serwera ze swojego projektu LogBrew.

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

### Wywołaj init_logbrew() po utworzeniu aplikacji

`init_logbrew()` zapisuje span dla każdego żądania i każdy nieobsłużony błąd jako problem. `logbrew.logging_handler` wysyła wpisy Twojego loggera. Wysyłaliśmy do lokalnego serwera LogBrew, więc nasza kopia przekazała też `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)
```

### Odczytaj problem i logi

Ponownie wysłaliśmy te same 4 żądania i odczytaliśmy projekt kluczem odczytu. Błąd 500 stał się 1 problemem nazwanym od szablonu trasy. 4 logi z `/taps/ipa` mają 1 wspólne ID śladu. 422 i 404 nie utworzyły problemu.

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

Wynik

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

### Sprawdź, co zachowuje problem

Problem zachowuje typ wyjątku, trasę i 21 ramek stosu, ale nie komunikat. LogBrew wpisuje w jego miejsce `Unhandled exception`.

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

Wynik

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

### Zachowaj komunikat dzięki handlerowi wyjątków

Z handlerem wyjątków z góry LogBrew nadal zapisał problem, a log `request failed` zachował komunikat, którego problem nie ma.

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

Wynik

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

## Co zobaczyliśmy podczas testu

Uruchomiliśmy 1 aplikację FastAPI 0.165.0 z uvicorn 0.54.0 na Pythonie 3.13.5, wywołaliśmy każdą trasę przez curl i odczytaliśmy wyjście serwera. Potem dodaliśmy logbrew-fastapi 0.1.14 i odczytaliśmy, co zapisał lokalny serwer LogBrew.

uvicorn wypisał ślad stosu każdego nieobsłużonego wyjątku, z handlerem i bez niego. Błędy, które FastAPI zamienia na odpowiedź, na przykład 422 albo `HTTPException`, dały tylko linię dostępu.

| Żądanie | `status_code` | Wypisany ślad stosu | Problem w LogBrew |
| --- | --- | --- | --- |
| `/kegs/7` | `500` | Tak | Tak |
| `/kegs/abc` | `422` | Nie | Nie |
| `/missing` | `404` | Nie | Nie |

## Poziomy logów FastAPI i wyjście uvicorn

Python ma 5 poziomów, `DEBUG`, `INFO`, `WARNING`, `ERROR` i `CRITICAL`. Bez konfiguracji główny logger odrzuca każdy wpis poniżej `WARNING`.

uvicorn wypisuje linie dostępu i błędy we własnym formacie, a `basicConfig()` ich nie zmieniło. LogBrew zachowuje `warning`, `error` i `critical` bez zmian, a `DEBUG` i `INFO` zapisuje jako `info`.

|  | Bez konfiguracji | `basicConfig()` | LogBrew |
| --- | --- | --- | --- |
| `logger.debug()` | Nie | Z `LOG_LEVEL=DEBUG` | Nie |
| `logger.info()` | Nie | Tak | `info` |
| `logger.warning()` | Tak | Tak | `warning` |
| `logger.error()` | Tak | Tak | `error` |
| `logger.critical()` | Tak | Tak | `critical` |

## Co zapisuje LogBrew

`init_logbrew()` zapisuje 1 span na żądanie, nazwany od szablonu trasy, na przykład `GET /kegs/{keg_id}`. Nieobsłużony wyjątek dodaje problem z typem wyjątku, mechanizmem `fastapi.middleware`, `handled: false` i ramkami stosu.

Log zapisany w trakcie żądania ma ID śladu tego żądania. Żądania z 422 i 404 utworzyły spany bez błędu.

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

## Najczęściej zadawane pytania

### Jak skonfigurować logowanie w FastAPI?

Wywołaj `logging.basicConfig()` raz na początku `main.py`, a potem używaj `logging.getLogger()` w każdym module. Bez konfiguracji Python pomija `info` i `debug`.

### Jak obsłużyć wszystkie wyjątki w FastAPI?

Dodaj `@app.exception_handler(Exception)` i zwróć własną odpowiedź. Klient dostaje Twoją odpowiedź, a uvicorn i tak wypisuje ślad stosu.

### Dlaczego FastAPI zwraca 422?

Wartość w ścieżce, zapytaniu albo treści nie pasowała do swojego typu. `/kegs/abc` nie przeszło sprawdzenia `keg_id: int`, więc FastAPI zwróciło listę `detail` ze statusem 422.

### Co oznacza Exception in ASGI application?

Wyjątek wyszedł z Twojej trasy i żaden handler go nie zatrzymał. uvicorn loguje go ze śladem stosu, a klient dostaje `Internal Server Error` ze statusem 500.

## Zobacz każdy błąd FastAPI razem z jego trasą

logbrew-fastapi zapisuje każdy nieobsłużony błąd jako problem nazwany od szablonu trasy i wysyła Twoje logi ze śladem ich żądania. Zacznij od hojnego darmowego planu, bez karty.

[Zacznij za darmo](https://logbrew.co/pl)

## Źródła

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

## Więcej przewodników po agentach, Pythonie, Node.js i React

- [Dodaj serwer MCP do Claude Code i Codex](https://logbrew.co/pl/guides/mcp-server-claude-code-codex)
- [Jak używać AGENTS.md w Claude Code i Codex](https://logbrew.co/pl/guides/agents-md)
- [Napraw błąd Claude 529 overloaded i błąd 429 rate limit](https://logbrew.co/pl/guides/claude-overloaded-rate-limit-error)
- [Skonfiguruj moduł Python logging z właściwymi poziomami i przechwytywaniem wyjątków](https://logbrew.co/pl/guides/python-logging)
- [Logowanie strukturalne z formatem logów i poziomami, które przeszukasz po polu](https://logbrew.co/pl/guides/structured-logging)
- [Skonfiguruj logowanie w Node.js z Pino lub Winston i nie zgub żadnego błędu](https://logbrew.co/pl/guides/node-logging)
- [Skonfiguruj logowanie w Django i zachowaj ślad stosu każdego błędu 500](https://logbrew.co/pl/guides/django-logging)
- [Dodaj error boundary w React i loguj błędy, których nie łapie](https://logbrew.co/pl/guides/react-error-boundary)
- [ID śladu a ID spanu, rozłożone na prawdziwym nagłówku traceparent](https://logbrew.co/pl/guides/trace-id)
- [Przewodniki po błędach, logach, śladach, metrykach i wydaniach](https://logbrew.co/pl/guides)
