---
title: "Skonfiguruj logowanie w Django i zachowaj ślad stosu każdego błędu 500"
description: "Z DEBUG = False i bez LOGGING Django nie wypisało śladu stosu dla błędu 500. Oto konfiguracja LOGGING, poziomy logów i wysyłanie błędów do LogBrew, przetestowane na Django 6.1."
canonical: "https://logbrew.co/pl/guides/django-logging"
last_updated: "2026-11-21"
---

# Skonfiguruj logowanie w Django i zachowaj ślad stosu każdego błędu 500

Z `DEBUG = False` i bez `LOGGING` Django nie wypisało śladu stosu dla błędu 500. Oto konfiguracja `LOGGING`, poziomy logów i wysyłanie błędów do LogBrew, przetestowane na Django 6.1.

Przetestowane 21 listopada 2026 z użyciem Python 3.13.5, Django 6.1.3, logbrew-sdk 0.1.29, logbrew-django 0.1.12 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/django-logging

## Co Django wypisuje bez `LOGGING` i co dostaje LogBrew

| Zdarzenie | Wypisane bez `LOGGING` | 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` |
| `logger.exception()` | Komunikat i ślad stosu | Log z wyjątkiem |
| `ValueError` w widoku | Tylko linia dostępu | Problem |
| `Http404` | Tylko linia dostępu | Span, bez problemu |

6 zdarzeń w Django 6.1.3 z `DEBUG = False`, potem te same z naszym słownikiem `LOGGING` i logbrew-django 0.1.12.

## Skonfiguruj logowanie w Django

### Zobacz, co Django wypisuje bez LOGGING

Nasza aplikacja ma 1 logger o nazwie `taproom` i 4 widoki. Z `DEBUG = False` i bez `LOGGING` Django wypisało `warning` i wyższe poziomy jako zwykły tekst, a `debug` i `info` pominęło. Błąd 500 dał tylko linię dostępu, bez śladu stosu.

```bash
import logging

from django.http import Http404, JsonResponse
from django.urls import path

logger = logging.getLogger("taproom")


class CardDeclined(Exception):
    pass


def pour(request, tap):
    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 JsonResponse({"tap": tap})


def keg(request, keg_id):
    raise ValueError(f"keg {keg_id} is empty")


def missing(request):
    raise Http404("no such tap")


def pay(request):
    try:
        raise CardDeclined("card declined")
    except CardDeclined:
        logger.exception("payment failed")
        return JsonResponse({"error": "card declined"}, status=402)


urlpatterns = [
    path("taps/<str:tap>/", pour),
    path("kegs/<int:keg_id>/", keg),
    path("missing/", missing),
    path("pay/", pay),
]
```

Wynik

```text
keg below 10%
keg empty
cooler offline
[21/Nov/2026 00:41:16] "GET /taps/ipa/ HTTP/1.1" 200 14
[21/Nov/2026 00:41:16] "GET /kegs/7/ HTTP/1.1" 500 145
[21/Nov/2026 00:41:16] "GET /missing/ HTTP/1.1" 404 179
payment failed
Traceback (most recent call last):
  File "urls.py", line 32, in pay
    raise CardDeclined("card declined")
urls.CardDeclined: card declined
[21/Nov/2026 00:41:16] "GET /pay/ HTTP/1.1" 402 26
```

### Dodaj słownik LOGGING do settings.py

Skieruj główny logger na konsolę i zostaw `disable_existing_loggers` na `False`, aby własne loggery Django działały dalej. Teraz `django.request` wypisało błąd 500 ze śladem stosu na poziomie `ERROR`, a 404 na poziomie `WARNING`.

```bash
LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {
        "plain": {"format": "{levelname} {name} {message}", "style": "{"},
    },
    "handlers": {
        "console": {"class": "logging.StreamHandler", "formatter": "plain"},
    },
    "root": {
        "handlers": ["console"],
        "level": os.environ.get("LOG_LEVEL", "INFO"),
    },
}
```

Wynik

```text
INFO taproom tap ipa opened
WARNING taproom keg below 10%
ERROR taproom keg empty
CRITICAL taproom cooler offline
[21/Nov/2026 00:41:20] "GET /taps/ipa/ HTTP/1.1" 200 14
ERROR django.request Internal Server Error: /kegs/7/
Traceback (most recent call last):
  File "django/core/handlers/exception.py", line 56, in inner
    response = get_response(request)
  File "django/core/handlers/base.py", line 199, in _get_response
    response = wrapped_callback(request, *callback_args, **callback_kwargs)
  File "urls.py", line 23, in keg
    raise ValueError(f"keg {keg_id} is empty")
ValueError: keg 7 is empty
[21/Nov/2026 00:41:20] "GET /kegs/7/ HTTP/1.1" 500 145
WARNING django.request Not Found: /missing/
[21/Nov/2026 00:41:20] "GET /missing/ HTTP/1.1" 404 179
ERROR taproom payment failed
Traceback (most recent call last):
  File "urls.py", line 32, in pay
    raise CardDeclined("card declined")
urls.CardDeclined: card declined
WARNING django.request Payment Required: /pay/
[21/Nov/2026 00:41:20] "GET /pay/ HTTP/1.1" 402 26
```

### Odczytaj poziom ze środowiska

Słownik `LOGGING` powyżej czyta `LOG_LEVEL`. Uruchom serwer z `LOG_LEVEL=DEBUG`, a linia `debug` pojawi się bez zmiany kodu.

```bash
LOG_LEVEL=DEBUG python manage.py runserver
```

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
[21/Nov/2026 00:41:21] "GET /taps/ipa/ HTTP/1.1" 200 14
```

### Zaloguj przechwycony wyjątek przez logger.exception()

Wewnątrz `except` metoda `logger.exception()` loguje na poziomie `ERROR` i dodaje ślad stosu. Nasz widok `pay` zwrócił też odpowiedź 402, więc `django.request` zalogowało `Payment Required` na poziomie `WARNING`.

```bash
def pay(request):
    try:
        raise CardDeclined("card declined")
    except CardDeclined:
        logger.exception("payment failed")
        return JsonResponse({"error": "card declined"}, status=402)
```

Wynik

```text
ERROR taproom payment failed
Traceback (most recent call last):
  File "urls.py", line 32, in pay
    raise CardDeclined("card declined")
urls.CardDeclined: card declined
WARNING django.request Payment Required: /pay/
```

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

### Zainstaluj pakiety

`logbrew-django` dodaje span dla każdego żądania i zapisuje każdy nieobsłużony błąd widoku jako problem. `logbrew-sdk` zawiera klienta i handler logowania. Użyj klucza serwera ze swojego projektu LogBrew.

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

### Dodaj middleware i handler do settings.py

Wstaw ten kod po `MIDDLEWARE` i `LOGGING`. `LogBrewDjangoMiddleware` musi być pierwszy w `MIDDLEWARE`. `LogBrewLoggingHandler` wysyła każdy wpis loggera `taproom`. Wysyłaliśmy do lokalnego serwera LogBrew, więc nasza kopia przekazała `endpoint=` do `HttpTransport()`.

```bash
import logging
import os

from logbrew_django import configure_logbrew
from logbrew_sdk import HttpTransport, LogBrewClient, LogBrewLoggingHandler

MIDDLEWARE = ["logbrew_django.LogBrewDjangoMiddleware", *MIDDLEWARE]

client = LogBrewClient.create(api_key=os.environ["LOGBREW_SERVER_API_KEY"])
logging.getLogger("taproom").addHandler(LogBrewLoggingHandler(client))
configure_logbrew(
    client=client, transport=HttpTransport(), service_name="taproom"
)
```

### Odczytaj problem i logi

Ponownie wywołaliśmy 4 widoki i odczytaliśmy projekt kluczem odczytu. Błąd 500 stał się 1 problemem nazwanym od trasy. Logi `taproom` zachowały swoje poziomy, a `debug` nie trafił, bo poziom główny to `INFO`. 404 nie utworzył problemu.

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

Wynik

```text
Issues (1)
- 4ca6e2fb-76d2-57d9-879a-5a4410756489 unresolved error priority=medium GET /kegs/<int:keg_id>/ failed occurrences=1 users=unknown last_seen=2026-11-21T06:44:49.579Z service=taproom trace=980168dd9976432da150838cb57f0f04 assignee=unassigned [unversioned / production]
Logs (5)
- error payment failed service=taproom trace=430c4481db414e84bec813f60aa9aa93 [unversioned / production]
- critical cooler offline service=taproom trace=a407e883564e4ab486dd9a4921971ad4 [unversioned / production]
- info tap ipa opened service=taproom trace=a407e883564e4ab486dd9a4921971ad4 [unversioned / production]
- warning keg below 10% service=taproom trace=a407e883564e4ab486dd9a4921971ad4 [unversioned / production]
- error keg empty service=taproom trace=a407e883564e4ab486dd9a4921971ad4 [unversioned / production]
```

### Sprawdź, co zachowują problem i log

Problem zachowuje typ wyjątku i trasę, ale nie komunikat. LogBrew wpisuje w jego miejsce `Unhandled exception`. Log z `logger.exception()` zachowuje nazwę i komunikat wyjątku, plik, funkcję i linię.

```bash
logbrew issues --since 1h --json | jq '.[0].attributes | {
  message, exception,
  route: .metadata.routeTemplate,
  frames: (.stackFrames | length)
}'
logbrew read logs --since 1h --severity error --search payment --json |
  jq '.[0].attributes.metadata | {
    exceptionName, exceptionMessage, fileName, functionName, lineNumber
  }'
```

Wynik

```text
{
  "message": "Unhandled exception",
  "exception": {
    "mechanism": {
      "handled": false,
      "type": "django.middleware"
    },
    "type": "ValueError"
  },
  "route": "/kegs/<int:keg_id>/",
  "frames": 2
}
{
  "exceptionName": "CardDeclined",
  "exceptionMessage": "card declined",
  "fileName": "urls.py",
  "functionName": "pay",
  "lineNumber": 34
}
```

## Co zobaczyliśmy podczas testu

Uruchomiliśmy 1 aplikację Django 6.1.3 na Pythonie 3.13.5 z `runserver` i `DEBUG = False`, wywołaliśmy 4 widoki przez curl i odczytaliśmy wyjście serwera. Potem dodaliśmy logbrew-django 0.1.12 i odczytaliśmy, co zapisał lokalny serwer LogBrew.

Z `DEBUG = True` i bez `LOGGING` Django wypisało też ślad stosu błędu 500. Aplikacja, która w środowisku deweloperskim pokazuje ślady stosu, na produkcji może więc nie pokazać żadnego.

|  | Bez `LOGGING` | Z `LOGGING` |
| --- | --- | --- |
| `logger.debug()` | Nie | Z `LOG_LEVEL=DEBUG` |
| `logger.info()` | Nie | Tak |
| `logger.warning()` | Tak | Tak |
| Ślad stosu błędu 500 | Nie | Tak |
| Linia dla 404 | Nie | Tak |

## Poziomy logów Django i logger `django.request`

Django używa 5 poziomów Pythona, `DEBUG`, `INFO`, `WARNING`, `ERROR` i `CRITICAL`. Poziom główny w `LOGGING` odrzuca każdy wpis poniżej niego.

`django.request` loguje odpowiedź 5xx na poziomie `ERROR`, a odpowiedź 4xx na poziomie `WARNING`. Tylko 500 z wyjątku miał ślad stosu.

LogBrew zachowuje `warning`, `error` i `critical` bez zmian, a `DEBUG` i `INFO` zapisuje jako `info`.

| Odpowiedź | `django.request` | Ślad stosu |
| --- | --- | --- |
| `500` | `ERROR` | Tak |
| `404` | `WARNING` | Nie |
| `402` | `WARNING` | Nie |

## Co zapisuje LogBrew

Middleware zapisuje 1 span na żądanie, nazwany od szablonu trasy, na przykład `GET /kegs/<int:keg_id>/`. Wyjątek w widoku dodaje problem z typem wyjątku, mechanizmem `django.middleware` i `handled: false`.

Problem nie zachowuje komunikatu wyjątku. Aby go zachować, zaloguj błąd przez `logger.exception()`, tak jak robi to widok `pay`.

Log zapisany w trakcie żądania ma ID śladu tego żądania. `Http404` i inne wyjątki 4xx tworzą span ze swoim statusem i bez problemu.

- `LogBrewDjangoMiddleware`
  - Problem: `GET /kegs/<int:keg_id>/ failed`
  - `exception.type`: `ValueError`
  - `mechanism`: `django.middleware`
  - `handled`: `false`
  - Ramki stosu: 2
- `LogBrewLoggingHandler`
  - Komunikat: `payment failed`
  - `exceptionName`: `CardDeclined`
  - `exceptionMessage`: `card declined`
  - `lineNumber`: `34`

## Najczęściej zadawane pytania

### Dlaczego Django nie loguje błędów 500?

Z `DEBUG = False` domyślna konfiguracja wysyła błędy `django.request` tylko do `mail_admins`, który wysyła je e-mailem do `ADMINS`. Dodaj słownik `LOGGING` z handlerem konsoli na głównym loggerze, aby je wypisać.

### Jak ustawić poziom logów w Django?

Ustaw `level` na głównym loggerze w `LOGGING`. Odczytaj go ze zmiennej środowiskowej, na przykład `LOG_LEVEL`, aby zmieniać go bez zmiany kodu.

### Jak zalogować wyjątek ze śladem stosu w Django?

Wywołaj `logger.exception()` wewnątrz `except`. Loguje na poziomie `ERROR` i dodaje ślad stosu.

### Co robi disable_existing_loggers?

Przy `True` własne loggery Django milkną, gdy zadziała Twoje `LOGGING`, więc `django.request` nic nie wypisuje. Zostaw `False`.

## Zobacz każdy błąd Django razem z jego żądaniem

logbrew-django zapisuje każdy nieobsłużony błąd widoku jako problem nazwany od 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

- [Django docs, Configuring logging](https://docs.djangoproject.com/en/6.0/topics/logging/#configuring-logging)
- [Django docs, Default logging configuration](https://docs.djangoproject.com/en/6.0/ref/logging/#django-s-default-logging-configuration)
- [Django docs, django.request](https://docs.djangoproject.com/en/6.0/ref/logging/#django-request)
- [django/django, django/utils/log.py](https://github.com/django/django/blob/main/django/utils/log.py)

## 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 FastAPI i obsłuż błędy bez utraty śladu stosu](https://logbrew.co/pl/guides/fastapi-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)
