Mengapa tingkat TRACE ada, dan kapan saya harus menggunakannya daripada DEBUG?

Di Log4J, Slf4J dan beberapa framework logging lainnya di Java, Anda memiliki dua level "developper" untuk logging:

• DEBUG
• JEJAK

Saya mengerti apa yang dilakukan DEBUG, karena penjelasannya jelas:

Level DEBUG menunjukkan peristiwa informasi berbutir halus yang paling berguna untuk men-debug aplikasi.

Tetapi tingkat TRACE tidak terlalu spesifik tentang kasus penggunaannya:

Level TRACE menunjuk acara informasi yang lebih halus daripada DEBUG

(Sumber: JavaDoc log4J )

Ini tidak memberi tahu saya bagaimana atau kapan menggunakan TRACE. Menariknya, ini bukan tingkat keparahan yang ditentukan dalam standar syslog . Googling untuk perbedaan antara TRACE dan DEBUG sepertinya hanya mengembalikan "gunakan DEBUG, oh, dan ada TRACE juga". Saya tidak dapat menemukan kasus penggunaan khusus untuk tingkat TRACE. Yang terbaik yang bisa saya temukan adalah halaman wiki lama ini memperdebatkan manfaat keberadaan level tersebut.

Ini, sebagai seorang arsitek, memunculkan banyak bendera dan pertanyaan di kepala saya. Jika seorang pengembang muda meminta saya untuk menambahkan TRACE ke arsitektur saya, saya akan membombardir dia dengan pertanyaan:

• Apa saja contoh informasi yang harus dicatat dengan TRACE dan bukan dengan DEBUG?
• Masalah spesifik apa yang saya selesaikan dengan mencatat informasi itu?
• Dalam contoh-contoh itu, apa saja properti dari informasi yang dicatat yang dengan jelas membedakan antara pencatatan di tingkat TRACE dan bukan pada tingkat DEBUG?
• Mengapa informasi itu harus melalui infrastruktur log?
  • Apa manfaat dari mempertahankan informasi itu dalam jurnal log daripada hanya menggunakan System.out.println?
  • Mengapa lebih baik menggunakan log untuk ini daripada debugger?
• Apa yang akan menjadi contoh kanonik dari penebangan di tingkat TRACE?
  • Apa keuntungan spesifik yang telah dibuat dengan masuk pada tingkat TRACE dan bukannya DEBUG dalam contoh?
  • Mengapa keuntungan itu penting?
  • Secara terbalik: Masalah apa yang saya hindari dengan mencatatnya di TRACE bukannya DEBUG?
  • Bagaimana lagi saya bisa menyelesaikan masalah itu? Mengapa masuk pada tingkat TRACE lebih baik daripada solusi lainnya?
• Haruskah pernyataan log tingkat TRACE dibiarkan dalam kode produksi? Mengapa?

Tetapi mengingat bahwa ia hadir dalam sebagian besar kerangka kerja utama, saya kira itu berguna untuk sesuatu? Jadi ... untuk apa TRACE, dan apa yang membedakannya dari DEBUG?

Apa contoh informasi yang harus dicatat dengan TRACE dan bukan dengan DEBUG?

Jika saya memiliki algoritme yang melewati beberapa langkah, level jejak akan mencetak info tentang masing-masing langkah tersebut di tingkat terbaik. Hal-hal seperti input dan output literal dari setiap langkah.

Secara umum, jejak akan mencakup semua debug (seperti halnya debug menyertakan semua peringatan dan kesalahan).

Masalah spesifik apa yang saya selesaikan dengan mencatat informasi itu?

Anda perlu untuk debug sesuatu yang output cara terlalu banyak data untuk login di luar membangun tertentu ketika Anda menargetkan bahwa hal tertentu dan tidak peduli tentang kesalahan atau info penebangan lain (karena volume info jejak akan mengaburkan mereka). Di beberapa penebang, Anda akan mengaktifkan modul tertentu hanya untuk melacak tingkat.

Dalam contoh-contoh itu, apa properti dari informasi yang dicatat yang dengan jelas membedakan antara pencatatan di tingkat TRACE dan bukan pada tingkat DEBUG?

Secara umum, penelusuran tingkat jejak tidak dapat digunakan untuk periode yang berkelanjutan karena sangat menurunkan kinerja aplikasi, dan / atau menciptakan banyak data log yang tidak berkelanjutan karena kendala disk / bandwidth.

Pencatatan level debug biasanya dapat berlangsung untuk periode yang lebih lama tanpa membuat aplikasi tidak dapat digunakan.

Mengapa informasi itu harus melalui infrastruktur log?

Tidak harus. Beberapa kerangka kerja memiliki tracelogger terpisah.

Biasanya ia berakhir di log karena traceloggers dan loggers normal memiliki kebutuhan yang sama berkaitan dengan penulisan ke disk / jaringan, penanganan kesalahan, rotasi log, dll.

Mengapa lebih baik menggunakan log untuk ini daripada debugger?

Karena debugger mungkin tidak dapat melampirkan ke mesin masalah. Anda mungkin tidak cukup tahu untuk mengetahui di mana bahkan mengatur breakpoints, atau untuk melangkah melalui kode. Anda mungkin tidak dapat mereproduksi kesalahan dalam debugger dengan andal, jadi gunakan log untuk menangkapnya "jika itu terjadi".

Tapi itu hanya nama. Seperti label lain, itu hanya nama orang yang memakai sesuatu, dan biasanya akan berarti berbeda untuk orang yang berbeda. Dan label itu sendiri kurang penting daripada bit gemuk yang mengacu label.

Perhatikan bahwa slf4j secara khusus merekomendasikan agar tidak menggunakan jejak ( http://slf4j.org/faq.html#trace ):

Singkatnya, meskipun kami masih mengecilkan penggunaan tingkat TRACE karena ada alternatif atau karena dalam banyak kasus permintaan log tingkat TRACE boros, mengingat bahwa orang terus memintanya, kami memutuskan untuk tunduk pada permintaan populer.

Secara pribadi, harapan saya adalah jejak untuk mencatat segala sesuatu (misalnya, bahkan hal-hal seperti "fungsi masuk MyFunc dengan argumen A, B, C pada waktu Y"). Kelemahan dari ini adalah bahwa ini tidak hanya sangat bising tetapi juga cenderung menyebabkan masalah ruang disk; Saya berharap logging tersebut dinonaktifkan selama operasi normal. Sisi positifnya adalah ini memberi Anda tingkat info yang mirip dengan apa yang akan Anda dapatkan ketika melangkah melalui program Anda dalam kasus di mana melampirkan debugger mungkin kurang praktis.

Secara umum, saya menemukan bahwa jejak biasanya lebih banyak usaha daripada pendekatan lain.

Level debug secara umum sepenuhnya arbitrer dan dapat bervariasi antara bahasa, perpustakaan, dan perusahaan.

Yang sedang berkata, di sini adalah bagaimana saya telah melihat mereka digunakan:

TRACE: digunakan untuk menunjukkan aliran program level logika. Memasuki fungsi? Apakah pernyataan "jika" memilih cabang utama atau "lain"? Itu adalah kandidat untuk ditelusuri. Dengan kata lain, penelusuran jejak biasanya digunakan untuk menentukan "Anda di sini." Ini berguna dalam konteks pernyataan logging lain yang mungkin mencatat kesalahan atau informasi lainnya. Pencatatan jejak dapat membantu menentukan lokasi, dalam kode, dari kesalahan atau peristiwa lain yang dicatat pada tingkat yang berbeda.

DEBUG: digunakan untuk membuang status variabel, kode kesalahan tertentu, dll. Misalnya: layanan web mungkin mengembalikan kode kesalahan 809214, yang dapat dicatat sementara aplikasi memberi tahu pengguna "komunikasi gagal." Bayangkan pengembang menerima log dari sistem pengguna lama setelah kesalahan terjadi dan bertanya-tanya " mengapa kegagalan terjadi?" itu adalah hal yang baik untuk masuk pada level debug. Contoh lain mungkin jika bug terus terjadi dalam produksi tetapi sulit untuk mereproduksi, debug log variabel atau peristiwa tertentu dalam modul merepotkan untuk membantu memberi tahu pengembang keadaan program saat kesalahan terjadi untuk membantu pemecahan masalah.

Biasanya seseorang akan mengkonfigurasi aplikasi untuk login pada level tertentu (atau lebih tinggi). Misalnya, penelusuran seringkali merupakan tingkat terendah: pencatatan pada tingkat itu mencatat segalanya. Level debug akan menghilangkan jejak tetapi termasuk level tinggi (mis. Peringatan dan kesalahan).

Manfaat memisahkan tingkat log adalah mengontrol jumlah yang dicatat. Untuk aplikasi yang kompleks, jejak logging mungkin berpotensi mencatat sejumlah besar data, sebagian besar tidak berguna sebagian besar waktu. Yang terbaik hanya mencatat informasi penting (mungkin beberapa informasi startup, kemudian hanya kesalahan) kecuali ada yang mencoba untuk mengetahui cara menyebabkan bug. Lebih jauh lagi, ini umumnya hanya berguna dalam lingkungan produksi jika debuggers dan alat pengembangan lainnya tidak ada.

Tidak ada batasan nyata untuk ini, tidak ada aturan yang mengatakan Anda harus login dengan cara tertentu. Hanya konvensi luas yang mungkin diikuti atau tidak diikuti oleh beberapa perpustakaan atau aplikasi.

Saya pikir jawaban Telastyn yang luar biasa dapat diringkas menjadi aturan singkat saya:

• DEBUG penebangan harus dapat digunakan dalam produksi (tetapi cenderung tetap tidak normal)
• TRACE penebangan diizinkan sedemikian rupa sehingga menggunakannya dalam produksi (selain untuk sesi tertentu / pendek) tidak layak

Ini aturan praktis saya

error   you need        to do something
warn    you might need  to do something
info    you need        to log this in production
debug   you might need  to log this in production
trace   everything that is happening (no performance concerns)

Asumsi di balik ini adalah bahwa tim ops akan melakukannya

• selalu ada set produksi untuk info tingkat log
• mungkin produksi diatur ke debug tingkat log
• tidak pernah mengatur produksi untuk melacak tingkat log

Berbekal asumsi itu, inilah cara Anda, sebagai pengembang, dapat menggunakan level log ...

Masalah # 1) tidak memperlambat kinerja produksi terlalu banyak

debugmemecahkan # 1. Andalah, sebagai pengembang, melakukan yang terbaik untuk menyeimbangkan informasi yang mungkin Anda perlukan dalam produksi dengan tidak memiliki terlalu banyak suara, Anda memperlambat mesin. Anda mengatakan "itu adalah ide yang bagus untuk terus-menerus mencatat ini dalam produksi (jika Anda mau)."

Masalah # 2) memiliki informasi verbal saat berkembang

tracememecahkan masalah # 2. Anda sama sekali tidak peduli apa dampaknya pada mesin produksi, tetapi Anda membutuhkan info itu saat mengembangkan kode. Anda mengatakan, "Saya tidak berjanji bahwa itu ide yang baik untuk selalu mencatat informasi ini dalam produksi."

Memang (seperti yang dikatakan orang lain), hal-hal ini sewenang-wenang; jadi pastikan tim pengembangan Anda (dan ops / tim pemantauan - karena mereka juga pengguna logging Anda) menyetujui sesuatu.

Apa yang akan menjadi contoh kanonik dari penebangan di tingkat TRACE?

MASUKKAN / KELUAR log dari suatu metode. Log ini membantu Anda melacak aliran program dan cenderung sangat berguna ketika:

1. Program tiba-tiba macet - Anda tahu persis fungsi mana yang macet dengan melihat baris terakhir dari log

2. Beberapa fungsi jahat diam-diam gagal dengan menyerap pengecualian

Mereka menjamin tingkat TRACE yang terpisah daripada hanya menggunakan DEBUG karena mengaktifkan log ENTRY / EXIT untuk setiap metode dalam basis kode Anda akan menghasilkan sejumlah besar log ekstra yang tidak masuk akal untuk selalu aktif , bahkan dalam konteks DEBUG.