ลง Log อย่างไรให้มีพิมพ์นิยม Standard
การลง Log มีความสำคัญอย่างยิ่งในการตรวจสอบการทำงานของ Program ซึ่งหากเราเขียน Program ไว้ดี แต่เขียน Log โดยใช้ สัณชาตญาณ ไม่มี standard ก็อาจจะเชิดชู Program นั้นว่าดีได้อย่างเต็มปากเต็มคำ
คำเตือน: บทความนี้อาจไม่เหมาะกับคนจริงเทสบน Production ผมต้องขออภัยมา ณ ที่นี้ด้วยขอรับ
Table of Content
— Phylumในการลง Log (การจัดประเภท Log)
— ว่ากันด้วยเรื่องของ Log Management
— Level ของการลง Log
— ตัวอย่าง
—ภาคประยุกต์
Phylum ในการลง Log (การจัดประเภท Log)
หากเรายังจำเรื่องของการแบ่ง ความหลากหลายของสิ่งมีชีวิต ในอาณาจักรสัตว์ (Kingdom Animalia)ในวิชาชีววิทยาได้ โดยใช้ลักษณะ จำนวนชั้นของเนื้อเยื่อ ช่องภายในตัว ปล้องขา ลำตัว ชนิดของท่อทางเดินอาหาร สมมาตร (symmetry) ของลำตัว ชนิดของระบบไหลเวียน ในการแบ่งประเภท ซึ่งจะจำแนกออกมาเป็น 9 ไฟลัมหลักๆ โดยมีตั้งแต่
1. ไฟลัมพอริเฟอรา (Phylum Porifera)
2. ไฟลัมซีเลนเทอราตา (Phylum Coelenterata)
3. ไฟลัมแพลทิเฮลมินทีส (Phylum Platyhelminthes)
4. ไฟลัมเนมาโทดา (Nematoda)
5. ไฟลัมแอนเนลิดา (Phylum Annelida)
6. ไฟลัมมอลลัสกา (Phylum Mollusca)
7. ไฟลัมอาร์โทรโพดา (Phylum Arthropoda)
8. ไฟลัมอีไคโนเดอร์มาตา (Phylum Echinodermata)
9. ไฟลัมคอร์ดาตา (Phylum Chordata) คนจะจัดอยู่ใน ไฟลัมคอร์ดาตา นี้แหละ
ก่อนที่ บล็อกไอที จะกลายร่างเป็น บล็อกชีวะ ขอเบรกความหลังไว้แต่เพียงเท่านี้
ทางรื้อฟื้นความรู้เก่า เชิญตามไปตำ (3 mins read)
ตัดภาพกลับมาที่ใจความสำคัญ ในเมื่อสิ่งมีชีวิตยังมีการจัดประเภท เพื่อช่วยให้เรารวบรวมสิ่งที่คล้ายคลึงกันออกมา คล้ายๆกับการ Cleaning data lake การลง Log ก็สามารถจัดประเภทตามความสำคัญได้เหมือนกัน
ศัพท์ชีวะเรียก การแบ่งประเภทของสัตว์ว่า Phylum (ไฟ-ลัม) ส่วนการลง Log จะใช้คำว่า Level (เล-เวล) ละกัน ซึ่งการแบ่งตามความสำคัญ ความหยาบ ความลับ ของข้อมูลที่จะลง Log
ว่ากันด้วยเรื่องของ Log Management
หากเคยประสบปัญหาในการงม Log การ debug ยุ่งยากอยู่ละก็ ขอแนะนำให้รู้จักกับการ Classification Log ผ่านการแบ่ง Level ในการ Write Log ซึ่ง machanism ที่พี่ๆ IT เมื่อปี 2001 ได้มีการคิดค้นเจ้าสิ่งนี้ขึ้นมา นอกจากจะลดความซับซ้อนซ่อนเงื่อน เอ๊ย ซ้อนเงื่อน เอ้อ ถูกแล้ววววว (Yell ถูกแล้วววว 7.5 ริคเตอร์) ยังสามารถใช้ Tool ในการ Filter Level ของ Log ได้อีกด้วย
เอาหล่ะๆ อย่างที่รู้กันดีว่าเวลาเราเขียนโปรแกรม เราสามารถเช็คการทำงานของโปรแกรมได้จากการ Debug โดยหากเราใช้ IDE ที่ทรงพลังอยู่ก็ใส่พวก BreakPoint เข้าไปแล้ว ให้ Program run command ไปถึงจุดที่จะทำการ debug ซึ่ง Step นี้ทำได้เฉพาะแค่จังหวะที่ Program on อยู่บน Environment: Dev หรือ QA ที่เรายังสามารถจำกัดคนใช้งานได้อยู่
หาก Program นั้น ได้หลุดออกจากวงโคจร Dev หรือ QA ไปเมื่อไหร่ เราจะสามารถใช้แว่นขยายแบบนักสืบเสาะหา เบาะแส ร่องรอย การทำงานของโปรแกรมได้เพียงจาก Log file ที่มีอยู่บน Production เท่านั้น และจะเป็นการดี ถ้าหาก Sense ของการลง Log ในหัวของทุกคนเข้าใจถึงความสำคัญ และมีมาตรฐานแบบเดียวกัน
ฉะนั้น
เราจำเป็นต้องไม่ลืมว่า การลง Log การจัดประเภท Log นั้นสำคัญเพียงใด อย่างไร เพราะเมื่อมีปัญหาเกิดขึ้น เราต้องใช้จินตนาการในการลำดับเหตุการณ์ที่เกิดขึ้นเพื่อ ประติดประต่อ และซึมซับเพื่อนำมามาถอดรหัสข้อความ Log ที่มีการทิ้งร่องลอยไว้ ก่อเกิดบทเรียนผ่าน Log เหล่านั้น
ทีนี้ จากที่เคยเขียนโปรแกรมหลายภาษามา Pattern ส่วนใหญ่ของการจัดประเภท Log ในภาษา Programming มักจะมีคุณลักษณะดังนี้
- Log Management เป็น 1 ใน Core ของ Programming Languages
- Log มีการแบ่ง Level ตามความละเอียด ความเปิดเผยได้ และความที่ต้องใส่ใจ หากเรียงตาม Level น้อยไปยัง Level มากแล้วละก็ จะเรียงจาก
- ละเอียด (มาก <==> ปานกลาง)
- ความ Privacy (เปิดเผยในไฟล์Logไม่ได้ <==> เปิดเผยในไฟล์Logได้)
- ความ Critical (ไม่ต้องใส่ใจก็ได้ <==> ความที่ต้องใส่ใจมาก) - Log สามารถ ตั้ง Level ที่จะให้พ่นใน Output channel (file, console) ได้
- Log Tool สามารถ Filter+Search ตาม Level หรือ Keyword ที่เราสนใจได้
- เราสามารถนำ Log ไปประยุกต์ใช้งานต่อได้ ไม่ว่าจะเป็น
- การทำ Big Data
- การตั้ง Watch Dog เพื่อดู Error บนระบบ หรือแม้กระทั้ง
- วัดประสิทธิภาพของ Program ก็ได้
เท่าที่ผมได้สังเกตมานะครับ ใครมี detail ที่อยากแชร์เพิ่มก็มาแบ่งปันกันน้า
Level ของการลง Log
Log Level มีการแบ่งระดับไว้ เป็นขั้นบันได เพื่อแยกความสำคัญของข้อมูลที่จะลง Log โดยจะเริ่มตั้งแต่ Level ที่ละเอียดที่สุด ไปจนถึง Level ที่รุนแรง ซึ่งการจัดแบ่ง Level แบบนี้ ส่งผลให้เกิดข้อดีในการจัดการกับ ข้อมูลที่เกิดขึ้นจากการลง Log ได้ในรูปแบบ เมื่อนำ Log ที่เกิดขึ้นไป
ซึ่ง concept นี้ก็ไม่ใช่เรื่องใหม่อะไร มีมานานเกือบ 20 ปีแล้ว ตัวผมเองไม่แน่ใจว่าในยุคปี y2k (2000) อยากรู้เหมือนกันว่า มนุษย์ IT ยุคนั้นมีการจัดการ Log แบ่งเลเวลเป็นแบบปัจจุบันบ้างหรือเปล่า และพวกพี่ๆ เขาจัดการยังไง
อย่าบอกนะว่า System.out.println กันรัวๆ แค่คิดก็ปวดหัวแล้ว
เท่าที่สืบค้นใน internet มา
java 1.4 (Initial เรื่อง Log Management) เริ่ม release แรกเมื่อ February 6, 2002
ส่วน library Log4j ( Logging Library บน Java) เริ่ม release แรกเมื่อ January 8, 2001
ถ้าจะเล่าให้ฟังซักอันนึงของยก Logging Library ชื่อดังทางฟาก JAVA มาเล่าละกัน นั่นก็คือ เจ้า Log4j ลุยยยยย
Ex. Log4j Logging Level
Log4j มีอยู่ด้วยกันทั้งหมด 6 ระดับ
โดยแต่ละระดับมีจุดประสงค์ต่างกันออกไป โดยเรื่อง Log ต้องแบ่งออกเป็น 2 เรื่องคือ
1). Log แต่ละ level โดยทั่วไปการแบ่ง Level ของ Log จะมีอยู่ด้วยกัน 5 ถึง 6 Levels โดยจะเริ่มจาก
ระดับความละเอียดมาก Privacy เปิดเผยในไฟล์ Log ไม่ได้ ไม่ต้องใส่ใจ ไต่ไปจนถึงระดับละเอียดปานกลาง Privacy เปิดเผยในไฟล์Logได้ และต้องคอยดูแหลเอาใส่ใจ
2). ตั้ง Config Level เพื่อแสดง Log ได้ 8 ระดับ (โดย OFF, ALL เป็นเพียงการ Flag Config เฉยๆ และตามด้วย TRACE, DEBUG, INFO, WARN, ERROR, FATAL)
มารู้จักจุดประสงค์ของ Log Level ต่างๆกัน : Log สามารถจัดแจงออกได้ 6 ประเภทส์
- trace : เอาไว้เขียนข้อมูลที่ละเอียดกว่า Debug ซึ่งส่วนใหญ่จะเอาไว้ลงข้อมูล พวก Hardware Serial การทำงานของ Memory หรือแม้กระทั่ง State Process job ที่เราสั่ง Run อยู่
- debug : เอาไว้เขียนเพื่อ Monitor หรือ flow การทำงาน ค่าภายในของโปรแกรมซึ่งมักจะใช้ช่วงเขียนโค้ดอยู่ หรือเอาไว้ใช้กับสถานการณ์ฉุกเฉิน หากต้องการ debug ของบน Production เราก็เปลี่ยน Log Level เป็น Debug แบบเถื่อนๆเลย
- info : ถัดมา ระดับ Info เป็นระดับที่เริ่มมีความ Standard ความ Generic ที่เอาไว้แสดงลำดับการทำงานของ Program หากเรามีการวางลำดับของ Log และ
อีกทั้งยังนำข้อมูลที่เกิดขึ้นขณะที่ระบบทำงาน ซึ่งหากเรา design การ Log ไว้ดี เราจะสามารถเอา Log มาทำการวิเคราะห์ต่อได้ด้วยนะ - warn : ระดับนี้เริ่มมีสัญญาณ เตือนภัย ว่า อาจจะมีสึนาบิค ( Tsunami + Bug = Tsunabig ) กำลังจะคุกคามโปรแกรมคุณในไม่ช้านะ เพื่อไม่ให้ใครรู้ว่าเรา อ่อนหัด เราก็จะมีการเตรียมการรับมือไว้
- error : ระดับนี้ คือ เกิดภัยพิบัติขึ้นใน Program ที่เราเขียนแล้วครับ โดยเมื่อเกิดภัยขึ้นสิ่งที่เราต้องจัดการต่อเป็นเรื่องที่สำคัญอย่างยิ่งยวด สิ่งที่ต้องทำคือ หาสิ่งกระตุ้นที่ทำให้เกิด Log นี้ กรี้ดออกมาแล้ว หาวิธีจัดการ กับการทำงานที่ไม่พึงประสงค์ใน Program ซะ
- fatal : ถ้า ระดับ error คือ เกิดภัยพิบัติ ระดับ fatal ก็คือ หายนะของ Program หรือเรียกว่าวันสิ้นโปรแกรม เพราะเมื่อมี log Level นี้ออกมาแปลว่า Program จะหยุดทำงาน แล้วหายไปนะ หายไปโดยที่ไม่มีอะไรกั้น ***
เพื่อให้การลง Log มีระบบระเบียบ
ก็มีกลไกที่ใช้ในการเปิด-ปิดการทำงานของ Log ให้สามารถปรับการทำงานเปิด-ปิดได้อย่าง Dynamic นั่นคือ เราสามารถ set Level ของ Log ในการเขียน output ออกมาได้โดย ทั้งนี้จะยึดจากความ Critical ของ Level ยิ่ง Critical ยิ่งได้รับสิทธิ์ในการ write output สูงกว่าชาวบ้าน 4 ชาวบ้าน 5 ****
จากรูป Level Log จะไล่จากความ Critical + Sensitive มาก ไปยัง น้อย ซึ่งหากเรา Set Level.OFF ผลลัพท์ก็จะไม่มี Log ออกเลย แต่หากเรา Set Level.INFO Log ก็จะออกตั้งแต่ Fatal ไปจนถึง Info เลย
เข้าใจจากตัวอย่าง
จากตัวอย่างโค๊ด เมื่อ Run java LogClass
instance log ใน LogClass ก็ได้ถือกำเนิดขึ้น แล้ว Config การลง Log ไว้เป็น Level.WARN ก็หมายถึง Log message จะ output ออกมาเฉพาะ Level ที่มีความสำคัญตั้งแต่ Warn ขึ้นไปซึ่งได้แก่ 3 levels นี้
Level.WARN, Level.ERROR, Level.FATALดังนั้น ผลลัพธ์จากการ Run ของ LogClass จะไม่มีการ Log
Trace message!
Debug message!
Info message
โผล่ออกมาให้เห็น
Beyond Logging
ก่อนจะจบบล็อก ผมไปเจอ web ที่เอา log มาวิเคราะห์ต่อยอด web นึงซึ่งคิดว่าเป็น idea ที่ต่อยอดจากการวิเคราะห์ log ที่ไม่ธรรมดา site นี้มีชื่อว่า DataDog ลองเข้าไปดูสิ่งที่เขารังสรรขึ้นมากัน ซึ่งส่วนตัวผมคิดว่าเป็น idea ที่ไม่เลวเลยทีเดียว อาจจะได้มุมมองแนวใหม่ครับ
Log ธรรมดาโลกไม่จำต้องใช้ …..***
OK, พอเรารู้เรื่อง Log แล้ว หากมีโจทย์ใหม่ว่า มี Code ที่เขียนที่มีความสมบูรณ์อยู่แล้ว มี test case ครบ Perfect ทั้ง Unit Test และ Feature เลย แต่แล้ววันนึง มี Requirement ใหม่ที่ต้องการให้ Log ข้อมูลเพิ่ม …….
ขอทิ้งไว้เท่านี้ เดี๋ยว Blog ใหม่เขียนเสร็จเมื่อไหร่จะมาแปะ Link ไว้ (นักดอง Blog ในตำนาน)
