9 Node.js Logger Libraries คุณสามารถลองเพื่อการบันทึกที่ดีขึ้น

คุณกำลังดิ้นรนกับการดีบักโค้ดของคุณหรือไม่? คุณกำลังค้นหาโซลูชันการบันทึกที่อาจทำให้การดีบักง่ายขึ้นหรือไม่ อ่านเพื่อเรียนรู้เพิ่มเติม.

การพัฒนาซอฟต์แวร์ต้องผ่านหลายขั้นตอน: การรวบรวมความต้องการ การวิเคราะห์ การเข้ารหัส การทดสอบ และการบำรุงรักษา จากขั้นตอนทั้งหมดเหล่านี้ ขั้นตอนการเข้ารหัส/การพัฒนาต้องใช้เวลาและความพยายามอย่างมาก วิศวกรซอฟต์แวร์จัดการกับข้อผิดพลาดทางไวยากรณ์ ข้อผิดพลาดทางตรรกะ และข้อผิดพลาดรันไทม์ ข้อผิดพลาดทางวากยสัมพันธ์ถูกระบุในเวลารวบรวมและเกิดขึ้นเนื่องจากรหัสที่ไม่ปฏิบัติตามกฎของภาษาโปรแกรม

ในทางกลับกัน ข้อผิดพลาดทางลอจิคัลและรันไทม์ไม่สามารถระบุได้โดย Integrated Development Environment (IDE) และมักจะดีบักและแก้ไขได้ยาก การแก้ไขจุดบกพร่องเป็นกระบวนการที่ใช้เวลานานและต้องมีการดีบักเป็นจำนวนมาก

การดีบักเป็นกระบวนการที่พยายามทำความเข้าใจว่าเหตุใดโค้ดที่เขียนขึ้นจึงไม่ทำงานตามที่คาดไว้ การแก้ปัญหาเป็นเรื่องง่ายเมื่อเราทราบข้อผิดพลาดและบรรทัดที่แน่นอนในโค้ดที่เกิดขึ้น ดังนั้น การบันทึกจึงมีประโยชน์มากสำหรับการดีบักโค้ด

การบันทึกคืออะไร?

การบันทึกเป็นเทคนิคที่ข้อความจะถูกบันทึกระหว่างการทำงานของโปรแกรม หนึ่งต้องบันทึกเฉพาะข้อความเหล่านั้น ซึ่งสามารถช่วยพวกเขาในการดีบัก ดังนั้น การรู้ว่าเมื่อใดควรเพิ่มคำสั่งบันทึกลงในโค้ดจึงมีความสำคัญอย่างยิ่ง นอกจากนี้ การแยกความแตกต่างระหว่างคำสั่งบันทึกก็มีความสำคัญเท่าเทียมกัน มีระดับต่างๆ ในการบันทึก เช่น ข้อมูล คำเตือน ข้อผิดพลาด การดีบัก และรายละเอียด คำสั่งข้อผิดพลาดและคำเตือนใช้สำหรับการจัดการข้อยกเว้น

ข้อมูลที่ส่งคืนจากฟังก์ชัน ผลลัพธ์หลังจากการจัดการอาร์เรย์ ข้อมูลที่ดึงมาจาก API เป็นต้น เป็นตัวอย่างข้อมูลบางส่วนที่สามารถบันทึกได้โดยใช้คำสั่งข้อมูล บันทึกการดีบักและ verbose ใช้เพื่ออธิบายรายละเอียดของข้อผิดพลาด

บันทึกการดีบักให้ข้อมูลเกี่ยวกับการติดตามสแต็ก พารามิเตอร์อินพุต-เอาต์พุต ฯลฯ “Verbose” ไม่มีรายละเอียดเท่ากับบันทึก “ดีบัก” แต่จะแสดงรายการเหตุการณ์ทั้งหมดที่เกิดขึ้น บันทึกจะถูกเขียนลงในคอนโซล ไฟล์ และสตรีมเอาต์พุต เครื่องมือการจัดการบันทึกสามารถใช้สำหรับการบันทึกที่มีโครงสร้างและจัดรูปแบบ

การบันทึก Node.js

Nodejs เป็นสภาพแวดล้อมรันไทม์จาวาสคริปต์ แอปพลิเคชัน Node.js เป็นแบบอะซิงโครนัสและไม่มีการบล็อก และใช้ในระบบที่ใช้ข้อมูลจำนวนมากและแบบเรียลไทม์ วิธีที่ดีที่สุดในการเรียนรู้เพิ่มเติมเกี่ยวกับ Node.js คือการอ่านบทช่วยสอนของ Node.js และเอกสารประกอบ จำเป็นต้องมีการบันทึกเพื่อปรับปรุงประสิทธิภาพ การแก้ไขปัญหา และการติดตามข้อผิดพลาด การเข้าสู่ระบบ Node.js สามารถทำได้โดยใช้ฟังก์ชัน inbuilt console.log นอกจากนี้ ฟังก์ชันดีบักยังเชื่อมโยงกับหลายแพ็คเกจและสามารถใช้งานได้อย่างมีประสิทธิภาพ

มิดเดิลแวร์ใช้สำหรับจัดการคำขอและการตอบกลับ มิดเดิลแวร์อาจเป็นแอปพลิเคชันหรือเฟรมเวิร์ก Javascript อื่นๆ การเข้าสู่ระบบมิดเดิลแวร์สามารถทำได้ผ่านแอปพลิเคชันและเราเตอร์ ตัวบันทึก Node.js ใด ๆ ต้องใช้คำสั่ง npm หรือ yarn install เพื่อติดตั้งตัวบันทึก

Npm ย่อมาจาก “Node Package Manager” และ YARN ย่อมาจาก “Yet Another Resource Negotiator” อย่างไรก็ตาม แนะนำให้ใช้ Yarn มากกว่า npm เนื่องจากเร็วกว่าและติดตั้งแพ็คเกจแบบคู่ขนานกัน

ตัวบันทึก Node.js ที่ดีที่สุดบางตัวมีการระบุไว้ด้านล่าง:

Pino

Pino เป็นห้องสมุดที่เป็นหนึ่งในเครื่องมือบันทึกที่ดีที่สุดสำหรับแอปพลิเคชัน Node.js เป็นโอเพ่นซอร์ส เร็วมาก และบันทึกคำสั่งในรูปแบบ JSON ที่อ่านง่าย ระดับบันทึกของ Pino ได้แก่ – ดีบัก เตือน ข้อผิดพลาด และข้อความข้อมูล อินสแตนซ์ตัวบันทึก Pino สามารถนำเข้าสู่โปรเจ็กต์ได้ และคำสั่ง console.log ต้องถูกแทนที่ด้วยคำสั่ง logger.info

ใช้คำสั่งต่อไปนี้เพื่อติดตั้ง Pino:

$ npm install pino   

บันทึกที่สร้างขึ้นนั้นซับซ้อนและอยู่ในรูปแบบ JSON โดยเน้นที่หมายเลขบรรทัดของบันทึก ประเภทของบันทึก เวลาที่บันทึก ฯลฯ Pino ทำให้เกิดการบันทึกค่าโสหุ้ยน้อยที่สุดในแอปพลิเคชัน และมีความยืดหยุ่นสูงในขณะประมวลผลบันทึก

Pino สามารถรวมเข้ากับเว็บเฟรมเวิร์ก เช่น Hapi, Restify, Express ฯลฯ บันทึกที่สร้างโดย Pino ยังสามารถเก็บไว้ในไฟล์ได้อีกด้วย มันใช้เธรดผู้ปฏิบัติงานสำหรับการทำงานและเข้ากันได้กับ TypeScript

วินสตัน

Winston สนับสนุนการบันทึกสำหรับเว็บเฟรมเวิร์กต่างๆ โดยเน้นที่ความยืดหยุ่นและความสามารถในการขยายเป็นหลัก รองรับการขนส่งหลายประเภทและสามารถจัดเก็บบันทึกในตำแหน่งไฟล์ต่างๆ การขนส่งเป็นสถานที่จัดเก็บข้อความบันทึก

  วิธีทำให้ปุ่มดีดออกของคีย์บอร์ด Mac มีประโยชน์อีกครั้ง

นอกเหนือจากการขนส่งในตัว เช่น Http, Console, File และ Stream แล้ว ยังรองรับการขนส่งอื่นๆ เช่น Cloud watch และ MongoDB มันทำการบันทึกภายใต้ระดับและรูปแบบต่างๆ ระดับการบันทึกบ่งบอกถึงความรุนแรงของปัญหา

ระดับการบันทึกต่างๆ มีดังนี้:

{
  error: 0,
  warn: 1,
  info: 2,
  http: 3,
  verbose: 4,
  debug: 5,
  silly: 6
}

รูปแบบเอาต์พุตบันทึกสามารถกำหนดเอง กรอง และรวมเข้าด้วยกันได้ บันทึกประกอบด้วยข้อมูลเกี่ยวกับการประทับเวลา ป้ายกำกับที่เกี่ยวข้องกับบันทึก มิลลิวินาทีที่ผ่านไปจากบันทึกก่อนหน้า ฯลฯ

วินสตันยังจัดการกับข้อยกเว้นและสัญญาที่ไม่มีใครจับได้ มันมีคุณสมบัติเพิ่มเติมเช่นการยื่นแบบสอบถามรันไทม์บันทึกการสตรีม ฯลฯ ประการแรกต้องติดตั้ง Winston จากนั้น อ็อบเจ็กต์การกำหนดค่าของ Winston พร้อมกับการขนส่งจะถูกสร้างขึ้นเพื่อจัดเก็บบันทึก ออบเจ็กต์ logger ถูกสร้างขึ้นโดยใช้ฟังก์ชัน createLogger() และข้อความบันทึกจะถูกส่งไปยังวัตถุนั้น

โหนด-บันยัน

Bunyan ใช้สำหรับบันทึกอย่างรวดเร็วใน node.js ในรูปแบบ JSON นอกจากนี้ยังมีเครื่องมือ CLI (Command Line Interface) สำหรับการดูบันทึก มันมีน้ำหนักเบาและรองรับสภาพแวดล้อมรันไทม์ต่างๆ เช่น Node.js, Browserify, WebPack และ NW.js รูปแบบ JSON ของบันทึกได้รับการเสริมสวยเพิ่มเติมโดยใช้ฟังก์ชันการพิมพ์ที่สวยงาม บันทึกมีระดับต่างๆ เช่น ร้ายแรง ข้อผิดพลาด คำเตือน ข้อมูล การดีบักและการติดตาม แต่ละอันสัมพันธ์กับค่าตัวเลข

ทุกระดับที่สูงกว่าระดับที่กำหนดไว้สำหรับอินสแตนซ์จะถูกบันทึกไว้ Bunyan stream เป็นสถานที่บันทึกเอาต์พุต ส่วนประกอบย่อยของแอปพลิเคชันสามารถบันทึกได้โดยใช้ฟังก์ชัน log.child() ตัวตัดไม้เด็กทั้งหมดถูกผูกไว้กับแอปพลิเคชันหลักเฉพาะ ประเภทสตรีมอาจเป็นไฟล์ ไฟล์หมุนเวียน ข้อมูลดิบ เป็นต้น ตัวอย่างโค้ดสำหรับกำหนดสตรีมแสดงอยู่ด้านล่าง:

var bunyan = require('bunyan');
var log = bunyan.createLogger({
    name: "foo",
    streams: [
        {
            stream: process.stderr,
            level: "debug"
        },
        ...
    ]
});

Bunyan ยังรองรับการบันทึก DTrace โพรบที่เกี่ยวข้องกับการบันทึก DTrace ได้แก่ log-trace, log-warn, log-error, log-info, log-debug และ log-fatal Bunyan ใช้ serializers เพื่อสร้างบันทึกในรูปแบบ JSON ฟังก์ชัน Serializer ไม่มีข้อยกเว้นและเป็นการป้องกัน

Loglevel

Loglevel ใช้สำหรับบันทึกในแอปพลิเคชัน Javascript นอกจากนี้ยังเป็นหนึ่งในเครื่องมือบันทึกที่ดีที่สุดของ Node.js เนื่องจากมีน้ำหนักเบาและเรียบง่าย มันบันทึกระดับที่กำหนดและใช้ไฟล์เดียวที่ไม่มีการขึ้นต่อกันสำหรับการบันทึก ระดับการบันทึกเริ่มต้นคือ “เตือน” เอาต์พุตบันทึกได้รับการจัดรูปแบบอย่างดีพร้อมกับหมายเลขบรรทัด วิธีการบางอย่างที่ใช้ในการบันทึก ได้แก่ การติดตาม แก้จุดบกพร่อง เตือน ข้อผิดพลาด และข้อมูล

ทนทานต่อความล้มเหลวในทุกสภาพแวดล้อม getLogger() เป็นวิธีการที่ใช้ในการดึงวัตถุ logger สามารถใช้ร่วมกับปลั๊กอินอื่น ๆ ได้เช่นกันเพื่อขยายคุณลักษณะต่างๆ ปลั๊กอินบางตัวรวมถึง loglevel-plugin-prefix, loglevel-plugin-remote, ServerSend และ DEBUG ปลั๊กอินสำหรับเพิ่มข้อความนำหน้าในการเข้าสู่ระบบแสดงอยู่ด้านล่าง:

var originalFactory = log.methodFactory;
log.methodFactory = function (methodName, logLevel, loggerName) {
    var rawMethod = originalFactory(methodName, logLevel, loggerName);

    return function (message) {
        rawMethod("Newsflash: " + message);
    };
};
log.setLevel(log.getLevel()); // Be sure to call setLevel method in order to apply plugin

บิลด์รันโดยใช้คำสั่ง npm run dist และสามารถรันการทดสอบได้โดยใช้คำสั่ง npm test ระดับบันทึกรองรับแพ็คเกจ Webjar, Bower และ Atmosphere Loglevel เวอร์ชันใหม่จะออกทุกครั้งที่มีการเพิ่มคุณสมบัติใหม่

  สุดยอดคู่มือการเปิดใช้งานโหมดมืดทุกที่

ซิกแนลเล่

Signale ประกอบด้วยตัวบันทึก 19 ตัวสำหรับแอปพลิเคชัน Javascript รองรับ TypeScript และการบันทึกที่มีขอบเขต ประกอบด้วยตัวจับเวลาที่ช่วยบันทึกการประทับเวลา ข้อมูล และชื่อไฟล์ นอกจากเครื่องมือตัดไม้ทั้ง 19 แบบ เช่น รอ สมบูรณ์ ร้ายแรง ชื่นชอบ ข้อมูล ฯลฯ เราสามารถสร้างบันทึกที่กำหนดเองได้

บันทึกที่กำหนดเองถูกสร้างขึ้นโดยการกำหนดออบเจ็กต์ JSON และฟิลด์ด้วยข้อมูลตัวบันทึก นอกจากนี้ยังสามารถสร้างตัวบันทึกแบบโต้ตอบได้ เมื่อตัวบันทึกแบบโต้ตอบถูกตั้งค่าเป็นจริง ค่าใหม่จากตัวบันทึกแบบโต้ตอบจะแทนที่ค่าเดิม

ส่วนที่ดีที่สุดของ Signale คือความสามารถในการกรองข้อมูลที่เป็นความลับหรือข้อมูลที่ละเอียดอ่อน ความลับหลายอย่างถูกเก็บไว้ในอาร์เรย์ addSecrets() และ clearSecrets() เป็นฟังก์ชันที่ใช้สำหรับเพิ่มและล้างข้อมูลลับจากอาร์เรย์ Boostnote, Docz, Shower, Taskbook และ Vant ใช้ Signale สำหรับการบันทึก ไวยากรณ์สำหรับการเรียก API จาก Signale มีดังนี้:

signale.<logger>(message[,message]|messageObj|errorObj)

จำนวนการดาวน์โหลด Signale มากกว่า 1 ล้านครั้งในขณะที่เขียนบทความนี้

ผู้ตามรอย

Tracer ใช้สำหรับสร้างข้อความบันทึกโดยละเอียด ข้อความบันทึกประกอบด้วยการประทับเวลา ชื่อไฟล์ หมายเลขบรรทัด และชื่อเมธอด สามารถติดตั้งแพ็คเกจ Helper เพื่อปรับแต่งรูปแบบการบันทึกผลลัพธ์ได้ แพ็คเกจตัวช่วยสามารถติดตั้งได้โดยใช้คำสั่งต่อไปนี้

 npm install -dev tracer

Tracer รองรับไฟล์ สตรีม และการขนส่ง MongoDB รองรับคอนโซลสีและเงื่อนไขตัวกรองในการบันทึก เริ่มแรก ต้องติดตั้งตัวติดตามโดยใช้การติดตั้ง npm ประการที่สอง ต้องสร้างวัตถุ logger และต้องเลือกชนิดของคอนโซล จากนั้น สามารถระบุระดับหรือประเภทบันทึกต่างๆ บนอ็อบเจ็กต์เพื่อการบันทึกเพิ่มเติม

ตัวกรองที่กำหนดเองสามารถสร้างได้โดยการกำหนดฟังก์ชันซิงโครนัสกับตรรกะทางธุรกิจที่มีอยู่ในเนื้อหาของฟังก์ชัน เทมเพลตขนาดเล็ก เช่น tinytim สามารถใช้สำหรับการบันทึกระบบได้

Cabin.js

Cabin ใช้สำหรับการบันทึกเซิร์ฟเวอร์และฝั่งไคลเอ็นต์ของแอปพลิเคชัน node.js ใช้ในกรณีที่จำเป็นต้องปิดบังข้อมูลที่สำคัญและละเอียดอ่อน ซึ่งรวมถึงหมายเลขบัตรเครดิต ส่วนหัว BasicAuth เกลือ รหัสผ่าน โทเค็น CSRF และหมายเลขบัญชีธนาคาร ข้อมูลโค้ดด้านล่างแสดงการบันทึกโดยใช้ Cabin.js

const Cabin = require('cabin');
const cabin = new Cabin();
cabin.info('hello world');
cabin.error(new Error('oops!'));

ประกอบด้วยชื่อฟิลด์มากกว่า 1,600 ชื่อ นอกจากนี้ยังเป็นไปตามหลักการของ Bring Your Own Logger (BYOL) ทำให้สามารถใช้งานร่วมกับเครื่องมือบันทึกอื่น ๆ เช่น Axe, Pino, Bunyan, Winston เป็นต้น ซึ่งช่วยลดต้นทุนการจัดเก็บในดิสก์เนื่องจากการสตรีมอัตโนมัติและบัฟเฟอร์ในห้องโดยสาร มันเข้ากันได้ข้ามแพลตฟอร์มและดีบั๊กได้ง่าย

การบันทึกฝั่งเซิร์ฟเวอร์ต้องใช้มิดเดิลแวร์สำหรับการกำหนดเส้นทางและการบันทึกเอาต์พุตอัตโนมัติ การบันทึกฝั่งเบราว์เซอร์ต้องใช้คำขอและสคริปต์ XHR ใช้ Axe ที่แสดงข้อมูลเมตา เช่น ข้อมูลเกี่ยวกับข้อมูล สแต็กเทรซ และข้อผิดพลาดอื่นๆ SHOW_STACK และ SHOW_META เป็นตัวแปรบูลีนที่ตั้งค่าเป็นจริงหรือเท็จเพื่อแสดงหรือซ่อนการติดตามสแต็กและข้อมูลเมตา

Npmlog

Npmlog เป็นตัวบันทึกประเภทพื้นฐานที่ npm ใช้ วิธีการบันทึกบางอย่างที่ใช้ ได้แก่ level, record, maxRecordSize, prefixStyle, heading และ stream นอกจากนี้ยังรองรับการบันทึกสี ระดับการบันทึกที่หลากหลายนั้นไร้สาระ, ละเอียด, ข้อมูล, เตือน, http และข้อผิดพลาด ข้อมูลโค้ดตัวอย่างสำหรับการใช้บันทึก npm แสดงอยู่ด้านล่าง

var log = require('npmlog')

// additional stuff ---------------------------+
// message ----------+                         |
// prefix ----+      |                         |
// level -+   |      |                         |
//        v   v      v                         v
    log.info('fyi', 'I have a kitty cat: %j', myKittyCat)

ข้อความทั้งหมดจะถูกระงับหากมีการระบุ “อินฟินิตี้” เป็นระดับบันทึก หากระบุ “-Infinity” เป็นระดับบันทึก ต้องเปิดใช้ตัวเลือกเพื่อดูข้อความบันทึกจึงจะดูบันทึกได้

  ค้นหาโทรศัพท์ของคุณด้วยการตะโกนว่า Marco & It Will Answer โปโล [Paid]

เหตุการณ์และวัตถุข้อความใช้สำหรับการบันทึก ข้อความนำหน้าจะถูกปล่อยออกมาเมื่อใช้เหตุการณ์คำนำหน้า สไตล์วัตถุใช้สำหรับการจัดรูปแบบบันทึก เช่น การเพิ่มสีให้กับข้อความและพื้นหลัง รูปแบบแบบอักษร เช่น ตัวหนา ตัวเอียง ขีดเส้นใต้ ฯลฯ แพ็คเกจบันทึก npm บางแพ็คเกจ ได้แก่ brolog, npmlogger, npmdate log เป็นต้น

คำราม

Roarr เป็นเครื่องมือบันทึกสำหรับ Node.js ที่ไม่ต้องการการเริ่มต้นและสร้างข้อมูลที่มีโครงสร้าง มี CLI และตัวแปรด้านสิ่งแวดล้อม มันเข้ากันได้กับเบราว์เซอร์ มันสามารถรวมเข้ากับ Fastify, Fastify, Elastic Search ฯลฯ มันสามารถแยกความแตกต่างระหว่างรหัสแอปพลิเคชันและรหัสการพึ่งพา ข้อความบันทึกทั้งหมดประกอบด้วยบริบท ข้อความ ลำดับ เวลา และเวอร์ชัน ระดับบันทึกต่างๆ ได้แก่ การติดตาม แก้จุดบกพร่อง ข้อมูล คำเตือน ข้อผิดพลาด และร้ายแรง ข้อมูลโค้ดตัวอย่างเกี่ยวกับวิธีการบันทึกคือ Roarr มีดังนี้:

import {
  ROARR,
} from 'roarr';

ROARR.write = (message) => {
  console.log(JSON.parse(message));
};

นอกจากนี้ การทำให้เป็นอนุกรมของข้อผิดพลาดสามารถทำได้ ซึ่งหมายความว่าสามารถบันทึกอินสแตนซ์ที่มีข้อผิดพลาดพร้อมกับบริบทของวัตถุได้ ตัวแปรสภาพแวดล้อมบางตัวซึ่งเจาะจงสำหรับ Node.js และ Roarr คือ ROARR_LOG และ ROARR_STREAM “adopt” เป็นฟังก์ชันที่ใช้กับ node.js เพื่อส่งต่อคุณสมบัติบริบทไปยังระดับต่างๆ ฟังก์ชั่นลูกสามารถใช้กับมิดเดิลแวร์ได้เช่นกันในขณะที่ทำการบันทึก

คำพูดสุดท้าย

การบันทึกเป็นวิธีการติดตามกิจกรรมและเหตุการณ์ต่างๆ ในระหว่างการดำเนินการโปรแกรม การบันทึกมีบทบาทสำคัญในการดีบักโค้ด นอกจากนี้ยังช่วยในการเพิ่มความสามารถในการอ่านโค้ด Node.js เป็นสภาพแวดล้อมรันไทม์ของจาวาสคริปต์แบบโอเพนซอร์ส เครื่องมือบันทึก Node.js ที่ดีที่สุดบางตัว ได้แก่ Pino, Winston, Bunyan, Signale, Tracer, Npmlog เป็นต้น เครื่องมือบันทึกแต่ละประเภทมีคุณสมบัติของตัวเอง เช่น การทำโปรไฟล์ การกรอง การสตรีม และการขนส่ง

ตัวบันทึกบางตัวรองรับคอนโซลสี และบางตัวก็เหมาะสำหรับการจัดการข้อมูลที่ละเอียดอ่อน บันทึกโดยละเอียดและจัดรูปแบบช่วยนักพัฒนาได้มากที่สุดในขณะที่พยายามแก้ไขจุดบกพร่องในโค้ด โดยทั่วไปแล้วรูปแบบ JSON เป็นที่นิยมสำหรับการบันทึก เนื่องจากจะบันทึกข้อมูลในรูปแบบของคู่คีย์-ค่าทำให้ใช้งานง่าย

ตัวตัดไม้ยังสามารถรวมเข้ากับแอปพลิเคชันอื่น ๆ และเข้ากันได้กับหลายเบราว์เซอร์ ขอแนะนำให้พิจารณาความต้องการและแอปพลิเคชันที่คุณกำลังสร้างก่อนเลือกประเภทของตัวบันทึกที่คุณต้องการใช้เสมอ

คุณอาจดูวิธีการติดตั้ง Node.js และ NPM บน Windows และ macOS

เรื่องล่าสุด

x