บทนำสู่ Node.js Performance API

Node.js มีเครื่องมืออันทรงพลังสำหรับการวัดและปรับปรุงประสิทธิภาพของแอปพลิเคชันของคุณ เครื่องมือหนึ่งคือ Performance API ซึ่งช่วยให้นักพัฒนาสามารถจับภาพประทับเวลาที่มีความละเอียดสูงและตัวชี้วัดประสิทธิภาพต่างๆ คู่มือนี้จะแนะนำคุณเกี่ยวกับส่วนประกอบสำคัญของ Node.js Performance API และวิธีการใช้งานอย่างมีประสิทธิภาพ

เหตุใดประสิทธิภาพจึงมีความสำคัญใน Node.js

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

สนใจที่จะเพิ่มเวลาตอบสนอง API ของคุณหรือไม่ บทความต่อไปนี้มีคำแนะนำทีละขั้นตอนเกี่ยวกับวิธีการเพิ่มเวลาตอบสนอง API ของคุณ

เหตุใดจึงใช้ Node.js Performance API

1. ระบุคอขวดด้านประสิทธิภาพ: คอขวดด้านประสิทธิภาพสามารถลดทอนประสบการณ์การใช้งานได้อย่างมาก การใช้ Performance API นักพัฒนาสามารถระบุช่วงเวลาที่เกิดความล่าช้าได้อย่างแม่นยำ ไม่ว่าจะในการดำเนินการฟังก์ชัน การโหลดทรัพยากร หรือการจัดการคำขอ HTTP ความแม่นยำนี้ช่วยให้สามารถปรับปรุงให้เหมาะสมได้
2. ปรับการใช้ทรัพยากรให้เหมาะสม: การตรวจสอบประสิทธิภาพช่วยในการทำความเข้าใจว่าทรัพยากรต่างๆ เช่น CPU และหน่วยความจำถูกนำไปใช้อย่างไร ด้วยการระบุการใช้ทรัพยากรอย่างไม่มีประสิทธิภาพ นักพัฒนาสามารถปรับโค้ดของตนให้เหมาะสมเพื่อให้มีประสิทธิภาพมากขึ้น ลดต้นทุน และปรับปรุงการปรับขนาด
3. ปรับปรุงประสบการณ์ผู้ใช้: แอปพลิเคชันที่ตอบสนองอย่างรวดเร็วจะมอบประสบการณ์การใช้งานที่ดีกว่า Performance API ช่วยในการวัดตัวชี้วัดสำคัญ เช่น Time to First Byte (TTFB) และ First Contentful Paint (FCP) ช่วยให้นักพัฒนาสามารถปรับปรุงที่นำไปสู่เวลาในการโหลดที่เร็วขึ้นและการโต้ตอบที่ราบรื่นยิ่งขึ้น
4. ปรับปรุงเสถียรภาพของแอปพลิเคชัน: การตรวจสอบประสิทธิภาพอย่างต่อเนื่องช่วยในการตรวจจับความผิดปกติและปัญหาที่อาจเกิดขึ้นก่อนที่จะกลายเป็นวิกฤต แนวทางเชิงรุกนี้ช่วยให้มั่นใจได้ถึงการทำงานที่สูงขึ้นและความน่าเชื่อถือของแอปพลิเคชัน

บทนำสู่ Node.js Performance API

Performance API ซึ่งเข้าถึงได้ผ่านโมดูล perf_hooks ช่วยให้นักพัฒนา Node.js มีชุดเครื่องมือที่ครอบคลุมสำหรับการวัดและวิเคราะห์ประสิทธิภาพของแอปพลิเคชัน มีข้อได้เปรียบที่สำคัญกว่าวิธีการแบบดั้งเดิม เช่น Date.now() โดยให้การจับเวลาที่มีความละเอียดสูงและแนวทางที่เป็นระบบมากขึ้นในการประเมินประสิทธิภาพ ในเมธอด Date.now() คุณจะเห็นบางอย่างเช่น;

const startTime = Date.now();
// call a function to perform a task()
console.log(`Task duration: ${Date.now() - startTime} milliseconds`);

ฟังก์ชัน Date.now() ทำงานได้ดี แต่อีกครั้งในขณะที่ดูเหมือนง่าย วิธีนี้อาจไม่น่าเชื่อถือเนื่องจากการเปลี่ยนแปลงนาฬิการะบบอาจทำให้การวัดค่าผิดพลาดได้

นี่คือที่มาของ Node.js Performance API เราต้องการที่จะสามารถวัดการใช้เวลาของแอปพลิเคชันของเราได้อย่างเต็มที่และรำคาญกับสิ่งต่างๆ เช่น นาฬิการะบบใช่ไหม

Node.js Performance API สร้างขึ้นจากเมธอดและคลาสหลักหลายรายการ ที่จัดเตรียมโดยโมดูล perf_hooks ซึ่งรวมถึง:

1. performance.now(),
2. performance.mark(),
3. performance.measure() และ
4. PerformanceObserver

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

การใช้ performance.now()

เมธอด performance.now() ส่งกลับการประทับเวลาที่มีความละเอียดสูงเป็นมิลลิวินาที ซึ่งมีประโยชน์สำหรับการวัดช่วงเวลาภายในแอปพลิเคชันของคุณด้วยความแม่นยำที่มากกว่า Date.now()

หากต้องการรับระยะเวลาของงาน ให้เพิ่มเมธอด performance.now() ที่จุดเริ่มต้นและจุดสิ้นสุดของการดำเนินการที่คุณต้องการวัดดังนี้

const { performance } = require('node:perf_hooks');
const start = performance.now();
// Perform some operations
const end = performance.now();
console.log(`Time taken: ${end - start} ms`);

ก่อนอื่น เรานำเข้า performance จากโมดูล node จากนั้นเราสร้างค่าคงที่เริ่มต้นและสิ้นสุดและกำหนดเมธอด performance.now ให้กับค่าเหล่านั้นเพื่อให้ได้เวลาที่ถูกต้องของการดำเนินการ

ผลลัพธ์ของโค้ดด้านบนควรมีลักษณะดังนี้

Time taken: 1253.**** ms.

การใช้ performance.mark()

เมธอด performance.mark() ใน Node.js ช่วยให้คุณสร้างการประทับเวลาที่มีชื่อ (หรือเครื่องหมาย) ณ จุดใดจุดหนึ่งในโค้ดของคุณ เครื่องหมายเหล่านี้ช่วยให้คุณวัดเวลาที่ใช้ไประหว่างส่วนต่างๆ ของแอปพลิเคชันของคุณ ทำให้คุณได้รับข้อมูลเชิงลึกเกี่ยวกับคอขวดด้านประสิทธิภาพ

const { performance } = require('node:perf_hooks');

performance.mark('A');
// Some operations
performance.mark('B');

ในตัวอย่างนี้ performance.mark('A') และ performance.mark('B') สร้างเครื่องหมายสองเครื่องหมายที่มีป้ายกำกับ 'A' และ 'B' ตามลำดับ

เครื่องหมายยังสามารถรวมรายละเอียดเพิ่มเติม ซึ่งอาจเป็นประโยชน์สำหรับการแก้ไขข้อบกพร่องหรือการวิเคราะห์เพิ่มเติม
performance.mark('A', { detail: 'Start of operation' }); performance.mark('B', { detail: 'End of operation' });

ในที่นี้ คุณสมบัติ detail ให้ข้อมูลเพิ่มเติมเกี่ยวกับสิ่งที่เครื่องหมายแต่ละรายการแสดงถึง
เมื่อคุณสร้างเครื่องหมายแล้ว คุณสามารถวัดระยะเวลาระหว่างเครื่องหมายเหล่านั้นได้โดยใช้ performance.measure()

การใช้ performance.measure()

performance.measure() เป็นฟังก์ชันภายใน Performance API ของ Node.js ที่คำนวณระยะเวลาระหว่างจุดที่ทำเครื่องหมายสองจุดในไทม์ไลน์การดำเนินการของแอปพลิเคชันของคุณโดยเฉพาะ โดยพื้นฐานแล้วจะสร้างรายการการวัดและจัดเก็บเวลาที่ผ่านไปสำหรับการเรียกดูและการวิเคราะห์ในภายหลัง

โปรดจำไว้ว่าในส่วน performance.mark() เราได้สร้างเครื่องหมายสองเครื่องหมาย: A & B ในส่วนนี้ เราจะทดสอบและดูว่า performance.mark() ทำงานอย่างไรกับ performance.measure()

performance.measure('A to B', 'A', 'B');
const measures = performance.getEntriesByType('measure');
measures.forEach(measure => {
  console.log(`${measure.name}: ${measure.duration}ms`);
});

สิ่งนี้จะสร้างการวัดชื่อ 'A to B' ซึ่งคำนวณเวลาที่ผ่านไประหว่างเครื่องหมาย 'A' และ 'B'

เมื่อคุณเรียกใช้โค้ดด้านบน ผลลัพธ์จะแสดงระยะเวลาระหว่างเครื่องหมาย 'A' และ 'B' นี่คือตัวอย่างของสิ่งที่คอนโซลอาจพิมพ์บางอย่างเช่น:

A to B: 12.345ms

ผลลัพธ์นี้ระบุว่าการดำเนินการระหว่างเครื่องหมาย 'A' และ 'B' ใช้เวลาประมาณ 12.345 มิลลิวินาทีในการทำให้เสร็จสมบูรณ์

การใช้ PerformanceObserver

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

ในการใช้ PerformanceObserver คุณต้องสร้างอินสแตนซ์และกำหนดฟังก์ชันเรียกกลับที่จะจัดการรายการประสิทธิภาพ นี่คือการตั้งค่าพื้นฐาน:

const { PerformanceObserver, performance } = require('node:perf_hooks');

const observer = new PerformanceObserver((list) => {
  list.getEntries().forEach((entry) => {
    console.log(entry);
  });
});

observer.observe({ entryTypes: ['mark', 'measure'] });

ในตัวอย่างนี้:

1. การนำเข้า PerformanceObserver และ performance: อ็อบเจกต์ PerformanceObserver และ performance ถูกนำเข้าจากโมดูล perf_hooks
2. การสร้าง Observer: อินสแตนซ์ของ PerformanceObserver ถูกสร้างขึ้นพร้อมกับฟังก์ชันเรียกกลับ ฟังก์ชันนี้ถูกเรียกใช้เมื่อมีการบันทึกรายการประสิทธิภาพใหม่
3. การสังเกตประเภทรายการ: เมธอด observer.observe ถูกเรียกใช้พร้อมกับอ็อบเจกต์ที่ระบุประเภทของรายการที่จะสังเกต (mark และ measure ในกรณีนี้)

กรณีการใช้งานจริงสำหรับ PerformanceObserver

1. การตรวจสอบประสิทธิภาพแบบเรียลไทม์:

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

2. การวิเคราะห์การโหลดทรัพยากร:

• โดยการสังเกตรายการการจับเวลาทรัพยากร นักพัฒนาสามารถวิเคราะห์วิธีการโหลดทรัพยากรต่างๆ (เช่น สคริปต์ สไตล์ชีต และรูปภาพ) ซึ่งช่วยในการปรับปรุงเวลาในการโหลด

3. การแก้ไขข้อบกพร่องและการสร้างโปรไฟล์:

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

4. ตัวชี้วัดประสิทธิภาพแบบกำหนดเอง:

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

การทดสอบแอปพลิเคชันใน Node.js

จนถึงตอนนี้ เราได้เรียนรู้เกี่ยวกับ Node.js Performance API เหตุใดจึงมีความสำคัญ วิธีการทำงาน และแตกต่างจากฟังก์ชัน Date.now() เริ่มต้นอย่างไร

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

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

บทสรุป

Node.js Performance API รวมถึงเครื่องมือต่างๆ เช่น performance.mark(), performance.measure() และ PerformanceObserver ช่วยให้นักพัฒนามีความสามารถอันทรงพลังในการตรวจสอบและปรับปรุงประสิทธิภาพของแอปพลิเคชัน ด้วยการใช้เครื่องมือเหล่านี้ คุณจะได้รับข้อมูลเชิงลึกที่แม่นยำเกี่ยวกับลักษณะประสิทธิภาพของแอปพลิเคชัน Node.js ของคุณ ระบุคอขวด และใช้การปรับปรุงให้เหมาะสมเพื่อเพิ่มประสิทธิภาพและประสบการณ์การใช้งาน

นอกเหนือจาก Performance API การใช้ แนวทางปฏิบัติของ API/แอปพลิเคชัน ที่ดีที่สุด และการทดสอบโหลดและการตรวจสอบที่แข็งแกร่งสามารถเพิ่มประสิทธิภาพโดยรวมของแอปพลิเคชันของคุณได้อย่างมาก ความพยายามเหล่านี้ร่วมกันทำให้มั่นใจได้ว่าแอปพลิเคชัน Node.js ของคุณทำงานได้อย่างราบรื่น ปรับขนาดได้อย่างมีประสิทธิภาพ และมอบประสบการณ์การใช้งานที่เหนือกว่า ซึ่งจะช่วยรักษาความได้เปรียบในการแข่งขันในตลาด