---
title: "Thiết lập logging Django và giữ traceback của mọi lỗi 500"
description: "Với DEBUG = False và không có LOGGING, Django không in traceback nào cho lỗi 500. Đây là cách thiết lập LOGGING, các cấp độ log và cách gửi lỗi đến LogBrew, đã thử trên Django 6.1."
canonical: "https://logbrew.co/vi/guides/django-logging"
last_updated: "2026-11-21"
---

# Thiết lập logging Django và giữ traceback của mọi lỗi 500

Với `DEBUG = False` và không có `LOGGING`, Django không in traceback nào cho lỗi 500. Đây là cách thiết lập `LOGGING`, các cấp độ log và cách gửi lỗi đến LogBrew, đã thử trên Django 6.1.

Đã thử nghiệm ngày 21 tháng 11, 2026 với Python 3.13.5, Django 6.1.3, logbrew-sdk 0.1.29, logbrew-django 0.1.12 và logbrew CLI 0.1.96

Tác giả [Furkan Erday](https://github.com/furkanerday). Furkan Erday là nhà sáng lập LogBrew. Anh xây dựng LogBrew bằng Claude Code và Codex mỗi ngày.

Canonical: https://logbrew.co/vi/guides/django-logging

## Django in gì khi không có `LOGGING`, và LogBrew nhận được gì

| Sự kiện | In ra khi không có `LOGGING` | Vấn đề hoặc log trong LogBrew |
| --- | --- | --- |
| `logger.debug()` | Bị bỏ | Bị bỏ ở `INFO` |
| `logger.info()` | Bị bỏ | Log `info` |
| `logger.warning()` | Chỉ thông điệp | Log `warning` |
| `logger.exception()` | Thông điệp và traceback | Log kèm exception |
| `ValueError` trong view | Chỉ dòng truy cập | Vấn đề |
| `Http404` | Chỉ dòng truy cập | Span, không có vấn đề |

6 sự kiện trong Django 6.1.3 với `DEBUG = False`, rồi cũng các sự kiện đó với dict `LOGGING` của chúng tôi và logbrew-django 0.1.12.

## Cấu hình logging Django

### Xem Django in gì khi không có LOGGING

Ứng dụng của chúng tôi có 1 logger tên `taproom` và 4 view. Với `DEBUG = False` và không có `LOGGING`, Django in `warning` trở lên dưới dạng văn bản thô và bỏ `debug` cùng `info`. Lỗi 500 chỉ in dòng truy cập, không có traceback.

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

Kết quả

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

### Thêm dict LOGGING vào settings.py

Gửi root logger ra console và giữ `disable_existing_loggers` ở `False` để các logger của chính Django vẫn chạy. Giờ `django.request` in lỗi 500 kèm traceback ở `ERROR`, và 404 ở `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"),
    },
}
```

Kết quả

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

### Đọc cấp độ từ biến môi trường

Dict `LOGGING` ở trên đọc `LOG_LEVEL`. Khởi động server với `LOG_LEVEL=DEBUG`, dòng `debug` sẽ xuất hiện mà không cần sửa code.

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

Kết quả

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

### Ghi log exception đã bắt bằng logger.exception()

Bên trong `except`, `logger.exception()` ghi log ở `ERROR` và thêm traceback. View `pay` của chúng tôi cũng trả về phản hồi 402, nên `django.request` ghi `Payment Required` ở `WARNING`.

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

Kết quả

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

## Gửi log và lỗi Django đến LogBrew

### Cài các gói

`logbrew-django` tạo một span cho mỗi request và ghi mỗi lỗi chưa xử lý trong view thành một vấn đề. `logbrew-sdk` chứa client và logging handler. Dùng một khóa server của dự án LogBrew của bạn.

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

### Thêm middleware và handler vào settings.py

Đặt đoạn code này sau `MIDDLEWARE` và `LOGGING`. `LogBrewDjangoMiddleware` phải đứng đầu trong `MIDDLEWARE`. `LogBrewLoggingHandler` gửi từng bản ghi của logger `taproom`. Chúng tôi gửi đến một server LogBrew cục bộ, nên bản của chúng tôi truyền `endpoint=` cho `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"
)
```

### Đọc lại vấn đề và log

Chúng tôi gọi lại 4 view và đọc dự án bằng một khóa đọc. Lỗi 500 thành 1 vấn đề mang tên route. Các log `taproom` giữ nguyên cấp độ, còn `debug` bị loại vì cấp độ root là `INFO`. 404 không tạo vấn đề nào.

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

Kết quả

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

### Kiểm tra vấn đề và log giữ những gì

Vấn đề giữ loại exception và route, nhưng không giữ thông điệp. LogBrew ghi `Unhandled exception` vào chỗ đó. Log từ `logger.exception()` giữ tên và thông điệp của exception, file, hàm và dòng.

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

Kết quả

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

## Kết quả khi chúng tôi thử nghiệm

Chúng tôi chạy 1 ứng dụng Django 6.1.3 trên Python 3.13.5 với `runserver` và `DEBUG = False`, gọi 4 view bằng curl và đọc output của server. Sau đó chúng tôi thêm logbrew-django 0.1.12 và đọc những gì một server LogBrew cục bộ đã lưu.

Với `DEBUG = True` và không có `LOGGING`, Django cũng in traceback của lỗi 500. Vậy một ứng dụng in traceback khi phát triển có thể không in gì trên production.

|  | Không có `LOGGING` | Có `LOGGING` |
| --- | --- | --- |
| `logger.debug()` | Không | Với `LOG_LEVEL=DEBUG` |
| `logger.info()` | Không | Có |
| `logger.warning()` | Có | Có |
| Traceback của lỗi 500 | Không | Có |
| Dòng cho 404 | Không | Có |

## Cấp độ log Django và logger django.request

Django dùng 5 cấp độ của Python, `DEBUG`, `INFO`, `WARNING`, `ERROR` và `CRITICAL`. Cấp độ root trong `LOGGING` bỏ mọi bản ghi thấp hơn nó.

`django.request` ghi phản hồi 5xx ở `ERROR` và phản hồi 4xx ở `WARNING`. Chỉ lỗi 500 do exception mới có traceback.

LogBrew giữ nguyên `warning`, `error` và `critical`, còn `DEBUG` và `INFO` được lưu thành `info`.

| Phản hồi | `django.request` | Traceback |
| --- | --- | --- |
| `500` | `ERROR` | Có |
| `404` | `WARNING` | Không |
| `402` | `WARNING` | Không |

## LogBrew ghi lại những gì

Middleware ghi 1 span cho mỗi request, mang tên template của route, ví dụ `GET /kegs/<int:keg_id>/`. Một exception trong view thêm một vấn đề với loại exception, cơ chế `django.middleware` và `handled: false`.

Vấn đề không giữ thông điệp của exception. Để giữ nó, ghi log lỗi bằng `logger.exception()`, như view `pay` đã làm.

Log được ghi trong một request mang trace ID của request đó. `Http404` và các exception 4xx khác tạo span với status của chúng và không tạo vấn đề.

- `LogBrewDjangoMiddleware`
  - Vấn đề: `GET /kegs/<int:keg_id>/ failed`
  - `exception.type`: `ValueError`
  - `mechanism`: `django.middleware`
  - `handled`: `false`
  - Stack frame: 2
- `LogBrewLoggingHandler`
  - Thông điệp: `payment failed`
  - `exceptionName`: `CardDeclined`
  - `exceptionMessage`: `card declined`
  - `lineNumber`: `34`

## Câu hỏi thường gặp

### Vì sao Django không ghi log lỗi 500?

Với `DEBUG = False`, cấu hình mặc định chỉ gửi lỗi `django.request` đến `mail_admins`, handler này gửi email cho `ADMINS`. Thêm một dict `LOGGING` có console handler trên root logger để in chúng ra.

### Làm sao đặt cấp độ log trong Django?

Đặt `level` cho root logger trong `LOGGING`. Đọc giá trị từ một biến môi trường như `LOG_LEVEL` để đổi mà không cần sửa code.

### Làm sao ghi log exception kèm traceback trong Django?

Gọi `logger.exception()` bên trong `except`. Nó ghi log ở `ERROR` và thêm traceback.

### disable_existing_loggers dùng để làm gì?

Với `True`, các logger của chính Django dừng lại khi `LOGGING` của bạn được áp dụng, nên `django.request` không in gì. Giữ nó ở `False`.

## Xem mọi lỗi Django cùng request của nó

logbrew-django ghi mỗi lỗi chưa xử lý trong view thành một vấn đề mang tên route, và gửi log của bạn kèm trace của request tương ứng. Bắt đầu với gói miễn phí rộng rãi, không cần thẻ.

[Bắt đầu miễn phí](https://logbrew.co/vi)

## Nguồn

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

## Thêm hướng dẫn cho agent, Python, Node.js và React

- [Thêm máy chủ MCP vào Claude Code và Codex](https://logbrew.co/vi/guides/mcp-server-claude-code-codex)
- [Dùng AGENTS.md trong Claude Code và Codex](https://logbrew.co/vi/guides/agents-md)
- [Khắc phục lỗi Claude overloaded 529 và lỗi rate limit 429](https://logbrew.co/vi/guides/claude-overloaded-rate-limit-error)
- [Thiết lập Python logging với đúng mức log và bắt ngoại lệ kèm traceback](https://logbrew.co/vi/guides/python-logging)
- [Structured logging với định dạng log và mức log bạn tìm được theo trường](https://logbrew.co/vi/guides/structured-logging)
- [Thiết lập log cho Node.js với Pino hoặc Winston mà không mất lỗi nào](https://logbrew.co/vi/guides/node-logging)
- [Thiết lập logging FastAPI và xử lý lỗi mà không mất traceback](https://logbrew.co/vi/guides/fastapi-logging)
- [Thêm error boundary cho React và ghi log những lỗi mà nó bỏ lọt](https://logbrew.co/vi/guides/react-error-boundary)
- [Trace ID và span ID, giải mã từ một header traceparent thật](https://logbrew.co/vi/guides/trace-id)
- [Hướng dẫn về lỗi, log, trace, chỉ số và bản phát hành](https://logbrew.co/vi/guides)
