---
title: "Bagaimana mengkonfigurasi dan menggunakan pencatatan"
version: 5.1
locale: id
source: https://docs.djangoproject.com/id/5.1/howto/logging/
canonical: https://djangodocs.dev/id/5.1/howto/logging/
---
# Bagaimana mengkonfigurasi dan menggunakan pencatatan

> **See also**
>
> - [Django logging reference](/id/5.1/ref/logging/#logging-ref)
> - [Django logging overview](/id/5.1/topics/logging/#logging-explanation)

Django menyediakan kerja [default logging configuration](/id/5.1/ref/logging/#default-logging-configuration) yang mudah diperpanjang.

## Membuat panggilan pencatatan dasar

Untuk mengirim pesan catatan dari dalam kode anda, anda dapat menempatkan panggilan pencatatan kedalamnya.

> **Jangan tergoda untuk menggunakan panggilan pencatatan dalam settings.py.**
>
> Cara dimana Django mencatat di konfigurasikan sebagai bagian dari fungsi `setup()` artinya bahwa panggilan mencatat ditempatkan dalam `settings.py` mungkin tidak bekerja seperti yang diharapkan, karena *logging will not be set up at that point*. Untuk menjelajahi mencatat, gunakan tampilan fungsi seperti disarankan dalam contoh dibawah ini.

Pertama, impor pustaka mencatat Python, dan kemudian ambil instance pencatat dengan [`logging.getLogger()`](https://docs.python.org/3/library/logging.html#logging.getLogger). Sediakan metode `getLogger()` dengan nama untuk mencirikan itu dan catatan yang dipancarkannya. Pilihan baik adalah menggunakan `__name__` (lihat [Gunakan namespace pencatat](#naming-loggers) di bawah untuk informasi lebih lanjut tentang ini) yang akan menyediakan nama dari modul Python saat ini sebagai jalur bertitik:

```
import logging

logger = logging.getLogger(__name__)
```

Merupakan konvensi yang baik untuk melakukan deklarasi ini pada tingkat modul.

Kemudian di dalam fungsi, sebagai contoh dalam tampilan, mengirimkan rekaman ke pencatat:

```
def some_view(request):
    ...
    if some_risky_state:
        logger.warning("Platform is running at risk")
```

Ketika kode ini dijalankan, [`LogRecord`](https://docs.python.org/3/library/logging.html#logging.LogRecord) mengandung pesan itu akan terkirim ke pencatat. Jika anda menggunakan konfigurasi pencatatan awalan Django, pesan akan muncul di konsol.

Tingkatan `WARNING` digunakan dalam contoh diatas adalah satu dari beberapa [logging severity levels](/id/5.1/topics/logging/#topic-logging-parts-loggers): `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`. Jadi, contoh lain mungkin:

```
logger.critical("Payment system is not responding")
```

> **Important**
>
> Rekaman dengan tingkatan rendah daripada `WARNING` tidak akan muncul dalam konsol secara awalan. Merubah perilaku ini membutuhkan konfigurasi tambahan.

## Menyesuaikan konfigurasi pencatatan

Meskipun konfigurasi mencatat Django bekerja di luar kotak, anda dapat mengendalikan tepatnya bagaimana catatan anda dikirim ke beragam tujuan - ke berkas catatan, layanan luar, surel dan lainnya -dengan beberapa konfigurasi tambahan.

Anda dapat mengkonfigurasi

- pencatatan pemetaan, untuk menentukan rekaman mana yang dikirim ke penangan mana
- penangan, untuk menentukan apa yang mereka lakukan dengan rekaman mereka terima
- penyaring, untuk menyediakan kendali tambahan terhadap perpindahan rekaman, dan bahkan merubah rekaman di tempat
- pembentuk, untuk merubah obyek [`LogRecord`](https://docs.python.org/3/library/logging.html#logging.LogRecord) menjadi string atau bentuk lain untuk dikonsumsi oleh manusia atau sistem lain

Ada beragam cara dari mengkonfigurasi pencatatan. Di Django, pengaturan [`LOGGING`](/id/5.1/ref/settings/#std-setting-LOGGING) adalah yang paling umum digunakan. Pengaturan menggunakan the [dictConfig format](https://docs.python.org/3/library/logging.config.html#logging-config-dictschema), dan memperpanjang [default logging configuration](/id/5.1/ref/logging/#default-logging-definition).

Lihat [Mengkonfigurasi catatan](/id/5.1/topics/logging/#configuring-logging) untuk penjelasan bagaimana pengaturan penyesuaian anda digabungkan dengan awalan Django.

Lihat [`Python logging documentation`](https://docs.python.org/3/library/logging.config.html#module-logging.config) untuk rincian cara lain dari konfigurasi pencatatan. Demi kesederhanaan, dokumentasi ini hanya akan mempertimbangkan konfigurasi melalui pengaturan `LOGGING`.

### Konfigurasi pencatatan dasar

Ketika mengkonfigurasi pencatatan, itu masuk akal untuk

#### Membuat sebuah dictionary LOGGING\`

Dalam `settings.py` anda:

```
LOGGING = {
    "version": 1,  # the dictConfig format version
    "disable_existing_loggers": False,  # retain the default loggers
}
```

Itu hampir selalu masuk akal untuk mempertahankan dan memperpanjang konfigurasi pencatatan awalan dengan mengatur `disable_existing_loggers` menjadi `False`.

#### Mengkonfigurasi penangan

Contoh ini mengkonfigurasikan penangan tunggal bernama `file`, yang menggunakan Python's [`FileHandler`](https://docs.python.org/3/library/logging.handlers.html#logging.FileHandler) untuk menyimpan catatan tingkatan `DEBUG` dan tertinggi ke berkas `general.log` (di akar proyek):

```python
LOGGING = {
    # ...
    "handlers": {
        "file": {
            "class": "logging.FileHandler",
            "filename": "general.log",
        },
    },
}
```

Kelas-kelas penangan berbeda mengambil pilihan konfigurasi berbeda. Untuk informasi lebih pada ketersediaan kelas-kelas penangan, lihat [`AdminEmailHandler`](/id/5.1/ref/logging/#django.utils.log.AdminEmailHandler) disediakan oleh Django dan beragam [`handler classes`](https://docs.python.org/3/library/logging.handlers.html#module-logging.handlers) disediakan oleh Python.

Tingkat pencatatan dapat juga di setel pada penangan (secara awalan, mereka menerima catatan pesan pada semua tingkatan). Menggunakan contoh diatas, menambahkan:

```python
{
    "class": "logging.FileHandler",
    "filename": "general.log",
    "level": "DEBUG",
}
```

akan menentukan sebuah konfigurasi penangan yang hanya menerima rekaman dari tingkatan `DEBUG` dan lebih tinggi.

#### Mengkonfigurasi pemetaan pencatatan

Untuk mengirim rekaman ke penangan ini, konfigurasikan pemetaan pencatatan untuk menggunakannya sebagai contoh:

```python
LOGGING = {
    # ...
    "loggers": {
        "": {
            "level": "DEBUG",
            "handlers": ["file"],
        },
    },
}
```

Nama pemetaan menentukan rekaman catatan mana yang akan diolah. Konfigurasi ini (`''`) adalah *unnamed*. Itu artinya bahwa dia akan mengolah rekaman dari *all* pencatat (lihat [Gunakan namespace pencatat](#naming-loggers) dibawah pada bagaimana menggunakan nama pemetaan untuk menentukan pencatat yang akan memproses catatannya).

Itu akan meneruskan pesan dari tingkatan `DEBUG` dan lebih tinggi ke penangan bernama `file`.

Catat bahwa pencatat dapat meneruskan pesan ke banyan penangan, jadi hubungan diantara pencatat dan penangan adalah many-to-many.

Jika anda menjalankan:

```
logger.debug("Attempting to connect to API")
```

dalam kode anda, anda akan menemukan bahwa pesan dalam berkas `general.log` di akar dari proyek.

#### Konfigurasikan pemformat

Secara awalan, keluaran catatan akhir mengandung pesan bagian dari tiap [`log record`](https://docs.python.org/3/library/logging.html#logging.LogRecord). Gunakan pembentuk jika anda ingin menyertakan data tambahan. Nawa awal dan tentukan bentukan anda - contoh ini menentukan nama bentukan `verbose` dan `simple`:

```python
LOGGING = {
    # ...
    "formatters": {
        "verbose": {
            "format": "{name} {levelname} {asctime} {module} {process:d} {thread:d} {message}",
            "style": "{",
        },
        "simple": {
            "format": "{levelname} {message}",
            "style": "{",
        },
    },
}
```

Katakunci `style` mengizinkan anda menentukan `{` for [`str.format()`](https://docs.python.org/3/library/stdtypes.html#str.format) atau `$` untuk bentukan [`string.Template`](https://docs.python.org/3/library/string.html#string.Template) ; awalan adalah `$`.

Lihat atribut [LogRecord attributes](https://docs.python.org/3/library/logging.html#logrecord-attributes) for the [`LogRecord`](https://docs.python.org/3/library/logging.html#logging.LogRecord) anda dapat sertakan.

Untuk memberlakukan pembentuk untuk penangan, tambah masukan `formatter` pada dictionary penangan mengacu pada pembentuk berdasarkan nama, sebagai contoh:

```python
"handlers": {
    "file": {
        "class": "logging.FileHandler",
        "filename": "general.log",
        "formatter": "verbose",
    },
}
```

#### Gunakan namespace pencatat

Konfigurasi catatan tidak bernama `''` menangkap catatan dari aplikasi Python apapun. Konfigurasi catatan bernama akan menangkap catatan hanya dari pencatat dengan nama yang cocok.

Namespace dari instance pencatat ditentukan menggunakan [`getLogger()`](https://docs.python.org/3/library/logging.html#logging.getLogger). Sebagai contoh dalam `views.py` dari `my_app`:

```
logger = logging.getLogger(__name__)
```

akan membuat pencatat dalam namespace ```my_app.views`. ``__name__``` mengijinkan anda mengatur pesan-pesan catatan menurut asal usulnya dalam aplikasi proyek anda otomatis. Dia juga memastikan bahwa anda tidak akan mengalami bentrokan nama.

Sebuah pemetaan pencatatan bernama `my_app.views` akan mengambil rekaman dari pencatat ini:

```python
LOGGING = {
    # ...
    "loggers": {
        "my_app.views": {...},
    },
}
```

Pemetaan pencatat bernama `my_app` akan menjadi tidak wajib, mengambil rekaman dari pencatat  dimanapun dalam namespace `my_app` (termasuk `my_app.views`, `my_app.utils`, dan sebagainya):

```python
LOGGING = {
    # ...
    "loggers": {
        "my_app": {...},
    },
}
```

Anda dapat juga menentukan namespace pencatat secara eksplisit:

```
logger = logging.getLogger("project.payment")
```

dan atur pemetaan pencatatan yang sesuai.

##### Menggunakan hierarki dan propagasi pencatatan

Penamanan pencatat adalah *hierarchical*. `my_app` adalah induk dari `my_app.views`, yang merupakan induk dari `my_app.views.private`. Meskipuin ditentukan sebaliknya, pemetaan pencatat akan menyebarkan rekaman proses mereka ke induk mereka - rekaman dari pencatat di namespace `my_app.views.private` akan ditangani dengan memetakan kedua `my_app` dan `my_app.views`.

Untuk mengelola perilaku ini, setel kunci propagasi pada pemetaan anda tentukan:

```
LOGGING = {
    # ...
    "loggers": {
        "my_app": {
            # ...
        },
        "my_app.views": {
            # ...
        },
        "my_app.views.private": {
            # ...
            "propagate": False,
        },
    },
}
```

`propagate` awalan adalah `True`. Di contoh ini, catatan dari `my_app.views.private` tidak akan ditangani oleh orang tua, tetapi catatan `my_app.views` akan.

### Mengkonfigurasikan pencatatan responsif

Mencatat adalah paling berguna ketika mengandung informasi sebanyak mungkin, tetapi bukan informasi uang anda tidak butuhkan - dan sebepara banyak anda butuhkan tergantung terhadap apa yang anda lakukan. Ketika anda sedang mencari kesalahan, anda butuh tingkatan informasi yang akan berlebihan dan tidak membantu jika anda harus berurusan dengannya di produksi.

Anda dapat menkonfigurasi catatan untuk menyediakan anda dengan tingkatan dari rincian yang anda butuhkan, ketika anda membutuhkannya. Daripada secara manuak merubah konfigurasi  untuk mencapai ini, cara terbaik adalah memberlakukan konfigurasi otomatis menurut lingkungan.

Sebagai contoh, anda dapat mensetel variabel lingkungan `DJANGO_LOG_LEVEL` dengan tepat di lingkungan pengembangan dan pementasan, dan memanfaatkannya di pemetaan pencatatan:

```
"level": os.getenv("DJANGO_LOG_LEVEL", "WARNING")
```

\- sehingga kecuali lingkungan menentukan tingkat catatan yang lebih rendah, konfigurasi ini hanya akan meneruskan rekaman dari kerasnya\`\`WARNING\`\` dan diatasnya untuk penangannya.

Pilihan lain dalam konfigurasi (seperti pilihan `level` atau `formatter` dari penangan) dapat dikelola dengan cara yang sama.