---
title: "Setup logging Django dan simpan traceback tiap error 500"
description: "Dengan DEBUG = False dan tanpa LOGGING, Django tidak mencetak traceback apa pun untuk error 500. Ini setup LOGGING, level log, dan cara mengirim error ke LogBrew, diuji di Django 6.1."
canonical: "https://logbrew.co/id/guides/django-logging"
last_updated: "2026-11-21"
---

# Setup logging Django dan simpan traceback tiap error 500

Dengan `DEBUG = False` dan tanpa `LOGGING`, Django tidak mencetak traceback apa pun untuk error 500. Ini setup `LOGGING`, level log, dan cara mengirim error ke LogBrew, diuji di Django 6.1.

Diuji pada 21 November 2026 dengan Python 3.13.5, Django 6.1.3, logbrew-sdk 0.1.29, logbrew-django 0.1.12, dan logbrew CLI 0.1.96

Oleh [Furkan Erday](https://github.com/furkanerday). Furkan Erday adalah pendiri LogBrew. Setiap hari ia membangun LogBrew dengan Claude Code dan Codex.

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

## Apa yang dicetak Django tanpa `LOGGING`, dan apa yang diterima LogBrew

| Event | Dicetak tanpa `LOGGING` | Masalah atau log di LogBrew |
| --- | --- | --- |
| `logger.debug()` | Dibuang | Dibuang di `INFO` |
| `logger.info()` | Dibuang | Log `info` |
| `logger.warning()` | Hanya pesan | Log `warning` |
| `logger.exception()` | Pesan dan traceback | Log beserta exception |
| `ValueError` di view | Hanya baris akses | Masalah |
| `Http404` | Hanya baris akses | Span, tanpa masalah |

6 event di Django 6.1.3 dengan `DEBUG = False`, lalu yang sama dengan dict `LOGGING` kami dan logbrew-django 0.1.12.

## Atur logging Django

### Lihat apa yang dicetak Django tanpa LOGGING

Aplikasi kami punya 1 logger bernama `taproom` dan 4 view. Dengan `DEBUG = False` dan tanpa pengaturan `LOGGING`, Django mencetak `warning` ke atas sebagai teks polos, lalu membuang `debug` dan `info`. Error 500 hanya mencetak baris aksesnya, tanpa 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),
]
```

Output

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

### Tambahkan dict LOGGING ke settings.py

Arahkan root logger ke konsol, dan biarkan `disable_existing_loggers` tetap `False` agar logger bawaan Django tetap aktif. Sekarang `django.request` mencetak error 500 beserta traceback di level `ERROR`, dan 404 di level `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"),
    },
}
```

Output

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

### Baca level dari variabel lingkungan

Dict `LOGGING` di atas membaca `LOG_LEVEL`. Jalankan server dengan `LOG_LEVEL=DEBUG`, dan baris `debug` muncul tanpa mengubah kode.

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

Output

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

### Catat exception yang ditangkap dengan logger.exception()

Di dalam `except`, `logger.exception()` mencatat di level `ERROR` dan menambahkan traceback. View `pay` kami juga mengembalikan respons 402, jadi `django.request` mencatat `Payment Required` di level `WARNING`.

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

Output

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

## Kirim log dan error Django ke LogBrew

### Pasang paketnya

`logbrew-django` membuat span untuk tiap permintaan dan mencatat tiap error view yang tidak tertangani sebagai masalah. `logbrew-sdk` berisi klien dan handler logging. Pakai kunci server dari proyek LogBrew kamu.

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

### Tambahkan middleware dan handler ke settings.py

Taruh kode ini setelah `MIDDLEWARE` dan `LOGGING`. `LogBrewDjangoMiddleware` harus ada di urutan pertama dalam `MIDDLEWARE`. `LogBrewLoggingHandler` mengirim tiap record dari logger `taproom`. Kami mengirim ke server LogBrew lokal, jadi salinan kami memberikan `endpoint=` ke `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"
)
```

### Baca kembali masalah dan log-nya

Kami memanggil ke-4 view lagi lalu membaca proyek dengan kunci baca. Error 500 menjadi 1 masalah yang diberi nama sesuai rute. Log `taproom` tetap dengan level-nya, dan `debug` tidak masuk karena level root adalah `INFO`. 404 tidak membuat masalah.

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

Output

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

### Cek apa yang disimpan masalah dan log

Masalah menyimpan tipe exception dan rute, tapi tidak menyimpan pesannya. LogBrew menulis `Unhandled exception` sebagai gantinya. Log dari `logger.exception()` menyimpan nama dan pesan exception, file, fungsi, dan barisnya.

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

Output

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

## Hasil pengujian kami

Kami menjalankan 1 aplikasi Django 6.1.3 di Python 3.13.5 dengan `runserver` dan `DEBUG = False`, memanggil 4 view dengan curl, lalu membaca output server. Setelah itu kami menambahkan logbrew-django 0.1.12 dan membaca apa yang disimpan server LogBrew lokal.

Dengan `DEBUG = True` dan tanpa `LOGGING`, Django juga mencetak traceback error 500. Jadi aplikasi yang mencetak traceback saat development bisa tidak mencetak apa pun di produksi.

|  | Tanpa `LOGGING` | Dengan `LOGGING` |
| --- | --- | --- |
| `logger.debug()` | Tidak | Dengan `LOG_LEVEL=DEBUG` |
| `logger.info()` | Tidak | Ya |
| `logger.warning()` | Ya | Ya |
| Traceback error 500 | Tidak | Ya |
| Baris untuk 404 | Tidak | Ya |

## Level log Django dan logger django.request

Django memakai 5 level dari Python, `DEBUG`, `INFO`, `WARNING`, `ERROR`, dan `CRITICAL`. Level root di `LOGGING` membuang tiap record di bawahnya.

`django.request` mencatat respons 5xx di level `ERROR` dan respons 4xx di level `WARNING`. Hanya 500 dari exception yang disertai traceback.

LogBrew menyimpan `warning`, `error`, dan `critical` apa adanya, lalu menyimpan `DEBUG` dan `INFO` sebagai `info`.

| Respons | `django.request` | Traceback |
| --- | --- | --- |
| `500` | `ERROR` | Ya |
| `404` | `WARNING` | Tidak |
| `402` | `WARNING` | Tidak |

## Apa yang dicatat LogBrew

Middleware mencatat 1 span per permintaan, diberi nama sesuai template rute, misalnya `GET /kegs/<int:keg_id>/`. Exception di view menambahkan masalah dengan tipe exception, mekanisme `django.middleware`, dan `handled: false`.

Masalah tidak menyimpan pesan exception. Untuk menyimpannya, catat error dengan `logger.exception()`, seperti yang dilakukan view `pay`.

Log yang ditulis selama permintaan membawa trace ID permintaan itu. `Http404` dan exception 4xx lainnya membuat span dengan status-nya, tanpa masalah.

- `LogBrewDjangoMiddleware`
  - Masalah: `GET /kegs/<int:keg_id>/ failed`
  - `exception.type`: `ValueError`
  - `mechanism`: `django.middleware`
  - `handled`: `false`
  - Frame stack: 2
- `LogBrewLoggingHandler`
  - Pesan: `payment failed`
  - `exceptionName`: `CardDeclined`
  - `exceptionMessage`: `card declined`
  - `lineNumber`: `34`

## Pertanyaan yang sering diajukan

### Kenapa Django tidak mencatat error 500?

Dengan `DEBUG = False`, setup bawaan hanya mengirim error `django.request` ke `mail_admins`, yang mengirimnya lewat email ke `ADMINS`. Tambahkan dict `LOGGING` dengan handler konsol di root logger untuk mencetaknya.

### Bagaimana cara mengatur level log di Django?

Atur `level` di root logger dalam `LOGGING`. Baca nilainya dari variabel lingkungan seperti `LOG_LEVEL` agar bisa diubah tanpa mengubah kode.

### Bagaimana cara mencatat exception beserta traceback di Django?

Panggil `logger.exception()` di dalam `except`. Fungsi ini mencatat di level `ERROR` dan menambahkan traceback.

### Apa fungsi disable_existing_loggers?

Dengan `True`, logger bawaan Django berhenti saat `LOGGING` kamu diterapkan, jadi `django.request` tidak mencetak apa pun. Biarkan tetap `False`.

## Lihat tiap error Django beserta permintaannya

logbrew-django mencatat tiap error view yang tidak tertangani sebagai masalah dengan nama rute, dan mengirim log kamu beserta trace permintaannya. Mulai dengan paket gratis yang lega, tanpa perlu kartu.

[Mulai gratis](https://logbrew.co/id)

## Sumber

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

## Panduan lain untuk agen, Python, Node.js, dan React

- [Tambahkan server MCP ke Claude Code dan Codex](https://logbrew.co/id/guides/mcp-server-claude-code-codex)
- [Pakai AGENTS.md di Claude Code dan Codex](https://logbrew.co/id/guides/agents-md)
- [Atasi error Claude overloaded 529 dan rate limit 429](https://logbrew.co/id/guides/claude-overloaded-rate-limit-error)
- [Siapkan Python logging dengan level log yang tepat dan penangkapan exception](https://logbrew.co/id/guides/python-logging)
- [Logging terstruktur dengan format log dan level log yang bisa dicari per field](https://logbrew.co/id/guides/structured-logging)
- [Siapkan logging Node.js dengan Pino atau Winston tanpa kehilangan satu error pun](https://logbrew.co/id/guides/node-logging)
- [Setup logging FastAPI dan tangani error tanpa kehilangan traceback](https://logbrew.co/id/guides/fastapi-logging)
- [Tambahkan error boundary React dan catat error yang lolos darinya](https://logbrew.co/id/guides/react-error-boundary)
- [Trace ID vs span ID, diurai dari header traceparent sungguhan](https://logbrew.co/id/guides/trace-id)
- [Panduan error, log, trace, metrik, dan rilis](https://logbrew.co/id/guides)
