Logging dan Debugging di Python: Menggunakan Logging Module dan Debugger Tools

Lima Level Logging dan Cara Mengaktifkannya

Saat aplikasi Python mulai berjalan di production, mengandalkan print() untuk memantau eksekusi menjadi tidak praktis dan berbahaya. Statement print() tidak memiliki informasi konteks seperti timestamp, severity, atau lokasi kejadian. Selain itu, kita harus menghapus atau mengomentari semua print() secara manual sebelum deploy, dan tidak ada cara untuk mengontrol level detail yang ingin ditampilkan.

Modul logging dari standard library Python menyediakan solusi yang jauh lebih matang. Modul ini mendefinisikan lima level severity yang membentuk hierarki: DEBUG, INFO, WARNING, ERROR, dan CRITICAL. Secara default, logging hanya akan menampilkan event dengan level WARNING ke atas. Artinya, jika kita mengirim log DEBUG atau INFO, log tersebut tidak akan muncul di console sampai kita mengubah threshold-nya.

Kita mengaktifkan logging menggunakan fungsi basicConfig(). Fungsi ini cukup dipanggil satu kali di awal aplikasi untuk mengatur konfigurasi dasar.

import logging

logging.basicConfig(level=logging.DEBUG)
logging.debug("Variabel x berisi nilai: 42")
logging.info("Aplikasi berhasil melakukan koneksi ke database")
logging.warning("Penggunaan memori mendekati batas: 85%")
logging.error("Gagal membaca file config: FileNotFoundError")
logging.critical("Database tidak merespon, aplikasi harus dihentikan")

Output (hasil eksekusi):

DEBUG:root:Variabel x berisi nilai: 42
INFO:root:Aplikasi berhasil melakukan koneksi ke database
WARNING:root:Penggunaan memori mendekati batas: 85%
ERROR:root:Gagal membaca file config: FileNotFoundError
CRITICAL:root:Database tidak merespon, aplikasi harus dihentikan

Setiap level memiliki fungsi spesifik. DEBUG digunakan untuk informasi diagnostik detail yang membantu saat development atau troubleshooting. INFO mencatat event normal seperti aplikasi berhasil start atau request berhasil diproses. WARNING menandakan ada potensi masalah yang perlu diperhatikan tetapi belum mengganggu operasional. ERROR menunjukkan kegagalan fungsi tertentu yang tidak mematikan aplikasi. CRITICAL disediakan untuk error fatal yang menghentikan aplikasi. Dengan sistem ini, kita cukup mengatur level threshold di basicConfig() — ubah ke WARNING di production untuk mengurangi noise, atau turunkan ke DEBUG saat debugging.

Mengirim Log ke File dengan Format Kustom

Menyimpan log hanya di console sangat tidak ideal untuk aplikasi production. Output console bersifat volatile — hilang saat terminal ditutup dan sulit dilacak secara historis. Solusi yang benar adalah mengarahkan log ke file permanen. Modul logging menyediakan FileHandler untuk keperluan ini.

Kita juga bisa mengatur format log menggunakan Formatter agar setiap baris log mengandung informasi yang kita butuhkan, seperti timestamp, level, nama logger, dan pesan.

import logging

logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    filename="aplikasi.log",
    filemode="a"
)

logging.info("Aplikasi berjalan pada mode production")
logging.warning("Koneksi database memakan waktu lebih dari 5 detik")

Output (file aplikasi.log):

2026-06-07 09:00:13 | INFO     | root | Aplikasi berjalan pada mode production
2026-06-07 09:00:13 | WARNING  | root | Koneksi database memakan waktu lebih dari 5 detik

Parameter format menggunakan sintaks %(key)s yang akan diisi oleh LogRecord. Beberapa key yang paling berguna: asctime untuk timestamp, levelname untuk severity, name untuk nama logger, dan message untuk pesan log. Parameter datefmt mengontrol format timestamp.

Untuk aplikasi yang berjalan dalam waktu lama, ukuran file log bisa membengkak tak terkendali. RotatingFileHandler dari logging.handlers menyediakan solusi rotasi otomatis.

from logging.handlers import RotatingFileHandler

handler = RotatingFileHandler("aplikasi.log", maxBytes=2048, backupCount=5)
handler.setFormatter(logging.Formatter(
    "%(asctime)s | %(levelname)-8s | %(message)s"
))

logger = logging.getLogger(__name__)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)

Output (hasil eksekusi — rotasi otomatis):

  aplikasi.log (1785 bytes)
  aplikasi.log.1 (2023 bytes)
  aplikasi.log.2 (2023 bytes)
  aplikasi.log.3 (2023 bytes)
  aplikasi.log.4 (2023 bytes)
  aplikasi.log.5 (2013 bytes)

Konfigurasi ini membatasi ukuran file log maksimal 2 KB. Setelah ukuran tersebut terlampaui, file lama akan di-rename secara otomatis menjadi aplikasi.log.1, aplikasi.log.2, dan seterusnya hingga maksimal lima file backup. Strategi rotasi ini mencegah disk penuh tanpa kehilangan data log sepenuhnya.

Hierarki Logger untuk Aplikasi Multi-Module

Semakin besar sebuah aplikasi Python, semakin banyak modul yang terlibat. Menggunakan satu logger global akan menyulitkan identifikasi asal pesan log. Modul logging menyelesaikan masalah ini dengan sistem hierarki logger yang berbasis namespace, mirip dengan struktur hierarki package Python.

Cara terbaik adalah menggunakan __name__ sebagai nama logger di setiap modul. Variabel __name__ secara otomatis berisi nama modul berdasarkan struktur package-nya, misalnya app.utils atau app.main.

# app/main.py
import logging
from app import utils

logger = logging.getLogger(__name__)
logging.basicConfig(
    level=logging.INFO,
    format="%(name)-20s | %(levelname)-8s | %(message)s"
)

logger.info("Memulai aplikasi")
utils.proses_data()

# app/utils.py
import logging

logger = logging.getLogger(__name__)

def proses_data():
    logger.info("Fungsi proses_data dipanggil")
    logger.debug("Detail: jumlah record = 150")

Output:

__main__             | INFO     | Memulai aplikasi
app.utils            | INFO     | Fungsi proses_data dipanggil

Setiap logger berada dalam hierarki berdasarkan nama. Logger app.utils merupakan child dari logger app, dan logger app merupakan child dari root. Secara default, properti propagate aktif — setiap log dari app.utils akan naik ke app lalu ke root. Ini berguna untuk menerapkan konfigurasi umum di parent sambil tetap memungkinkan kustomisasi di level child.

Kita bisa mengatur level berbeda untuk setiap modul. Misalnya, aktifkan DEBUG hanya untuk modul app.utils tanpa mengganggu modul lain:

logging.getLogger("app.utils").setLevel(logging.DEBUG)

Pendekatan ini sangat powerful untuk aplikasi besar. Tim backend bisa fokus pada log modul payment sementara tim infrastruktur memonitor log modul database, semuanya dari sistem logging yang sama.

Gambar: Diagram alur log event pada logger dan handler Python — Sumber: [Python Docs](https://docs.python.org/3/howto/logging.html)

Debugging Interaktif dengan Python Debugger

Logging bersifat pasif — kita menulis pesan ke file atau console lalu menganalisisnya setelah eksekusi selesai. Debugging, di sisi lain, bersifat interaktif: kita menghentikan eksekusi program pada titik tertentu untuk menginspeksi keadaan aplikasi secara langsung. Seperti menjeda video frame-by-frame untuk memeriksa detail yang terlewat saat diputar normal.

Python menyediakan debugger bawaan bernama pdb. Mulai Python 3.7, kita cukup menambahkan fungsi breakpoint() di titik mana pun dalam kode untuk memasuki sesi debugging interaktif.

def hitung_faktorial(n):
    hasil = 1
    for i in range(1, n + 1):
        hasil *= i
        breakpoint()
    return hasil

hitung_faktorial(3)

Simulasi sesi interaktif:

> .../main.py(6)hitung_faktorial()
-> return hasil
(Pdb) p i
3
(Pdb) p hasil
6
(Pdb) p n
3
(Pdb) c
6

Perintah c atau continue melanjutkan eksekusi hingga breakpoint berikutnya. n atau next menjalankan baris berikutnya tanpa masuk ke dalam fungsi. s atau step masuk ke dalam fungsi untuk melihat eksekusi internalnya. p atau print menginspeksi nilai variabel pada titik eksekusi yang terhenti. q atau quit keluar dari debugger dan menghentikan program.

breakpoint() dapat dipasang di dalam loop, di dalam kondisi if, atau di titik mana pun yang mencurigakan. Saat eksekusi terhenti, kita bisa mengakses semua variabel lokal, mengekspresikan kode Python apa pun secara langsung, dan menelusuri stack trace untuk memahami jalur eksekusi yang membawa program ke titik tersebut.

Gambar: Cheatsheet perintah pdb untuk debugging interaktif — Sumber: [nblock/pdb-cheatsheet](https://github.com/nblock/pdb-cheatsheet) (CC BY-SA 3.0)

Kapan Menggunakan Logging dan Kapan Debugging

Kedua alat ini memiliki fungsi yang saling melengkapi, bukan menggantikan satu sama lain. Logging digunakan terutama untuk monitoring production: mencatat semua event penting secara permanen, melacak error yang terjadi tanpa intervensi manual, dan menyediakan audit trail untuk kebutuhan compliance. Di lingkungan production, kita bisa mengatur logging pada level WARNING atau ERROR untuk menghindari banjir data, sambil tetap menangkap kejadian kritis.

Debugging digunakan selama development untuk menemukan root cause bug secara interaktif. Saat ada fitur baru yang tidak berjalan sesuai harapan, atau saat log menunjukkan error tetapi penyebabnya belum jelas, debugger memungkinkan kita menginspeksi keadaan aplikasi baris per baris. Debugging jarang digunakan di production karena sifatnya yang menghentikan eksekusi (blocking).

Aturan paling penting: hindari print() di production code. print() tidak memiliki level severity, tidak bisa dikonfigurasi, tidak menyertakan timestamp, dan tidak bisa diarahkan ke file. Untuk aplikasi modern, pertimbangkan juga structured logging dalam format JSON yang bisa langsung diintegrasikan dengan alat log management seperti Elasticsearch, Loki, atau CloudWatch. Structured logging memungkinkan mesin parsing membaca log kita secara otomatis untuk pencarian dan analisis yang lebih efisien. Kombinasi antara logging yang terstruktur dan debugging yang terarah akan mempercepat proses identifikasi dan resolusi masalah secara signifikan.

Logging dan debugging adalah keterampilan fundamental yang membedakan developer pemula dari developer profesional. Mulai gunakan logging module di project Python Anda berikutnya dan biasakan memanfaatkan breakpoint() saat menemukan bug yang sulit dilacak. Ingin menguasai Python secara mendalam beserta best practices software engineering seperti ini? Kunjungi Rumah Coding untuk kursus Python Programming dan program bootcamp intensif yang dirancang untuk membangun portofolio nyata.