Django menyediakan kerja default logging configuration yang mudah diperpanjang.
\nUntuk mengirim pesan catatan dari dalam kode anda, anda dapat menempatkan panggilan pencatatan kedalamnya.
\n\nPertama, impor pustaka mencatat Python, dan kemudian ambil instance pencatat dengan logging.getLogger(). Sediakan metode getLogger() dengan nama untuk mencirikan itu dan catatan yang dipancarkannya. Pilihan baik adalah menggunakan __name__ (lihat Gunakan namespace pencatat di bawah untuk informasi lebih lanjut tentang ini) yang akan menyediakan nama dari modul Python saat ini sebagai jalur bertitik:
import logging\n\nlogger = logging.getLogger(__name__)\nMerupakan konvensi yang baik untuk melakukan deklarasi ini pada tingkat modul.
\nKemudian di dalam fungsi, sebagai contoh dalam tampilan, mengirimkan rekaman ke pencatat:
\ndef some_view(request):\n ...\n if some_risky_state:\n logger.warning("Platform is running at risk")\nKetika kode ini dijalankan, 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: DEBUG, INFO, WARNING, ERROR, CRITICAL. Jadi, contoh lain mungkin:
logger.critical("Payment system is not responding")\nMeskipun 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.
\nAnda dapat mengkonfigurasi
\npencatatan 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 menjadi string atau bentuk lain untuk dikonsumsi oleh manusia atau sistem lain
Ada beragam cara dari mengkonfigurasi pencatatan. Di Django, pengaturan LOGGING adalah yang paling umum digunakan. Pengaturan menggunakan the dictConfig format, dan memperpanjang default logging configuration.
Lihat Mengkonfigurasi catatan untuk penjelasan bagaimana pengaturan penyesuaian anda digabungkan dengan awalan Django.
\nLihat Python logging documentation untuk rincian cara lain dari konfigurasi pencatatan. Demi kesederhanaan, dokumentasi ini hanya akan mempertimbangkan konfigurasi melalui pengaturan LOGGING.
Ketika mengkonfigurasi pencatatan, itu masuk akal untuk
\nDalam settings.py anda:
LOGGING = {\n "version": 1, # the dictConfig format version\n "disable_existing_loggers": False, # retain the default loggers\n}\nItu hampir selalu masuk akal untuk mempertahankan dan memperpanjang konfigurasi pencatatan awalan dengan mengatur disable_existing_loggers menjadi False.
Contoh ini mengkonfigurasikan penangan tunggal bernama file, yang menggunakan Python's FileHandler untuk menyimpan catatan tingkatan DEBUG dan tertinggi ke berkas general.log (di akar proyek):
LOGGING = {\n # ...\n "handlers": {\n "file": {\n "class": "logging.FileHandler",\n "filename": "general.log",\n },\n },\n}\nKelas-kelas penangan berbeda mengambil pilihan konfigurasi berbeda. Untuk informasi lebih pada ketersediaan kelas-kelas penangan, lihat AdminEmailHandler disediakan oleh Django dan beragam handler classes disediakan oleh Python.
Tingkat pencatatan dapat juga di setel pada penangan (secara awalan, mereka menerima catatan pesan pada semua tingkatan). Menggunakan contoh diatas, menambahkan:
\n{\n "class": "logging.FileHandler",\n "filename": "general.log",\n "level": "DEBUG",\n}\nakan menentukan sebuah konfigurasi penangan yang hanya menerima rekaman dari tingkatan DEBUG dan lebih tinggi.
Untuk mengirim rekaman ke penangan ini, konfigurasikan pemetaan pencatatan untuk menggunakannya sebagai contoh:
\nLOGGING = {\n # ...\n "loggers": {\n "": {\n "level": "DEBUG",\n "handlers": ["file"],\n },\n },\n}\nNama 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 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.
\nJika anda menjalankan:
\nlogger.debug("Attempting to connect to API")\ndalam kode anda, anda akan menemukan bahwa pesan dalam berkas general.log di akar dari proyek.
Secara awalan, keluaran catatan akhir mengandung pesan bagian dari tiap log record. Gunakan pembentuk jika anda ingin menyertakan data tambahan. Nawa awal dan tentukan bentukan anda - contoh ini menentukan nama bentukan verbose dan simple:
LOGGING = {\n # ...\n "formatters": {\n "verbose": {\n "format": "{name} {levelname} {asctime} {module} {process:d} {thread:d} {message}",\n "style": "{",\n },\n "simple": {\n "format": "{levelname} {message}",\n "style": "{",\n },\n },\n}\nKatakunci style mengizinkan anda menentukan { for str.format() atau $ untuk bentukan string.Template ; awalan adalah $.
Lihat atribut LogRecord attributes for the LogRecord anda dapat sertakan.
Untuk memberlakukan pembentuk untuk penangan, tambah masukan formatter pada dictionary penangan mengacu pada pembentuk berdasarkan nama, sebagai contoh:
"handlers": {\n "file": {\n "class": "logging.FileHandler",\n "filename": "general.log",\n "formatter": "verbose",\n },\n}\nKonfigurasi 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(). Sebagai contoh dalam views.py dari my_app:
logger = logging.getLogger(__name__)\nakan 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:
LOGGING = {\n # ...\n "loggers": {\n "my_app.views": {...},\n },\n}\nPemetaan 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):
LOGGING = {\n # ...\n "loggers": {\n "my_app": {...},\n },\n}\nAnda dapat juga menentukan namespace pencatat secara eksplisit:
\nlogger = logging.getLogger("project.payment")\ndan atur pemetaan pencatatan yang sesuai.
\nPenamanan 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:
\nLOGGING = {\n # ...\n "loggers": {\n "my_app": {\n # ...\n },\n "my_app.views": {\n # ...\n },\n "my_app.views.private": {\n # ...\n "propagate": False,\n },\n },\n}\npropagate awalan adalah True. Di contoh ini, catatan dari my_app.views.private tidak akan ditangani oleh orang tua, tetapi catatan my_app.views akan.
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.
\nAnda 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.
\nSebagai 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")\n- sehingga kecuali lingkungan menentukan tingkat catatan yang lebih rendah, konfigurasi ini hanya akan meneruskan rekaman dari kerasnya``WARNING`` dan diatasnya untuk penangannya.
\nPilihan lain dalam konfigurasi (seperti pilihan level atau formatter dari penangan) dapat dikelola dengan cara yang sama.