Saya baru-baru ini belajar tentang pemantauan nodejs. Meskipun saya tidak memiliki tenaga untuk belajar menulis versi pemantauan yang sederhana, saya tetap belajar cara mendapatkan indikator-indikator ini (setelah berkonsultasi dengan banyak informasi, saya merasa bahwa terlalu sedikit pengenalan konten ini di Internet domestik. Saya juga memilah poin pengetahuan node server, jadi saya akan merangkumnya dalam artikel ini dan membagikannya kepada Anda).
Mungkin ada masalah dengan beberapa indikator dalam artikel ini. Selamat datang di pertukaran. Faktanya, Anda dapat mengatur data ini dan menuliskannya ke dalam perpustakaan pemantauan dan menggunakannya dalam proyek kecil dan menengah Anda sendiri. Kemudian reaksi front-end memiliki alat seperti bizcharts dan g2, dan front-end menggambar sendiri layar besar data. Saya rasa dimensi data yang dikumpulkan oleh esay monitor tidak sekomprehensif milik kami.
Hambatan kinerja server biasanya sebagai berikut:
Penggunaan CPU dan beban CPU, keduanya dapat mencerminkan kesibukan mesin sampai batas tertentu.
PenggunaanCPU adalah sumber daya CPU yang digunakan oleh program yang sedang berjalan, yang menunjukkan bagaimana mesin menjalankan program pada titik waktu tertentu. Semakin tinggi tingkat penggunaannya, berarti mesin tersebut menjalankan banyak program saat ini, dan sebaliknya. Tingkat penggunaan berhubungan langsung dengan kekuatan CPU. Pertama-tama mari kita pahami API yang relevan dan beberapa penjelasan terminologi untuk membantu kita memahami kode untuk memperoleh penggunaan CPU.
os.cpus()mengembalikan array objek yang berisi informasi tentang setiap inti CPU logis.
model: string yang menentukan model inti CPU.
kecepatan: Angka yang menentukan kecepatan inti CPU dalam MHz.
kali: Objek yang berisi properti berikut:
CATATAN: Nilai nice hanya untuk POSIX. Pada sistem operasi Windows, nilai nice selalu 0 untuk semua prosesor.
Ketika melihat user dan kolom yang bagus, beberapa siswa bingung tentang kelebihannya, begitu juga saya, jadi saya menanyakan dengan cermat maksudnya, silakan lanjutkan.
penggunamenunjukkan proporsi waktu CPU berjalan dalam mode pengguna .
Eksekusi proses aplikasi dibagi menjadi mode pengguna dan mode kernel : CPU mengeksekusi logika kode proses aplikasi itu sendiri dalam mode pengguna, biasanya beberapa perhitungan logis atau numerik, CPU mengeksekusi panggilan sistem yang diprakarsai oleh proses dalam mode kernel, biasanya sebagai respons; untuk permintaan sumber daya proses.
Program ruang pengguna adalah proses apa pun yang bukan bagian dari kernel. Shell, kompiler, database, server web, dan program terkait desktop semuanya merupakan proses ruang pengguna. Jika prosesor tidak menganggur, wajar jika sebagian besar waktu CPU dihabiskan untuk menjalankan proses ruang pengguna.
Nice mewakili proporsi waktu CPU berjalan dalam mode pengguna prioritas rendah . Prioritas rendah berarti nilai proses yang bagus kurang dari 0.
penggunamewakili proporsi waktu CPU berjalan dalam mode kernel .
Secara umum, penggunaan CPU mode kernel tidak boleh terlalu tinggi kecuali proses aplikasi memulai panggilan sistem dalam jumlah besar. Jika terlalu tinggi berarti pemanggilan sistem memakan waktu lama, seperti operasi IO yang sering.
menunjukkan proporsi waktu CPU dalam keadaan idle, dimana CPU tidak memiliki tugas untuk dilakukan.
irq mewakili proporsi waktu CPU menangani interupsi perangkat keras .
Interupsi kartu jaringan adalah contoh tipikal: setelah kartu jaringan menerima paket data, ia memberitahukan CPU untuk diproses melalui interupsi perangkat keras. Jika lalu lintas jaringan sistem sangat padat, peningkatan penggunaan irq yang signifikan dapat diamati.
Jika status pengguna kurang dari 70%, status kernel kurang dari 35%, dan status keseluruhan kurang dari 70%, maka dapat dihitung sebagai status sehat.
Contoh berikut mengilustrasikan penggunaan metode os.cpus() di Node.js:
Contoh 1:
// Program Node.js untuk mendemonstrasikan
//os.cpus() metode
// Mengalokasikan modul os
const os = memerlukan('os');
// Mencetak nilai os.cpus()
konsol.log(os.cpus()); Keluaran:
[ { model:'Intel(R) Core(TM) i5-7200U CPU @ 2,50GHz',
kecepatan:2712,
kali:
{ pengguna:900000, bagus:0, sys:940265, menganggur:11928546, irq:147046 } },
{ model:'CPU Intel(R) Core(TM) i5-7200U @ 2,50GHz',
kecepatan:2712,
kali:
{ pengguna:860875, bagus:0, sys:507093, menganggur:12400500, irq:27062 } },
{ model:'CPU Intel(R) Core(TM) i5-7200U @ 2,50GHz',
kecepatan:2712,
kali:
{ pengguna:1273421, bagus:0, sys:618765, menganggur:11876281, irq:13125 } },
{ model:'CPU Intel(R) Core(TM) i5-7200U @ 2,50GHz',
kecepatan:2712,
kali:
{ user:943921, nice:0, sys:460109, idle:12364453, irq:12437 } } ] Berikut kode cara mendapatkan pemanfaatan cpu
const os = require('os');
const sleep = ms => Janji baru(resolve => setTimeout(resolve, ms));
kelas OSUtils {
konstruktor() {
this.cpuUsageMSDefault = 1000; //periode default penggunaan CPU}
/**
* Dapatkan penggunaan CPU untuk jangka waktu tertentu* @param { Number } Options.ms [Periode waktu, defaultnya adalah 1000ms, yaitu 1 detik]
* @param { Boolean } Options.percentage [benar (dikembalikan sebagai hasil persentase) |.
* @returns { Janji }
*/
async getCPUUsage(pilihan={}) {
const itu = ini;
biarkan { cpuUsageMS, persentase } = opsi;
cpuUsageMS = cpuUsageMS ||.itu.cpuUsageMSDefault;
const t1 = that._getCPUInfo(); // Informasi CPU pada titik waktu t1 menunggu tidur(cpuUsageMS);
const t2 = that._getCPUInfo(); // informasi CPU pada titik waktu t2 const idle = t2.idle - t1.idle;
const total = t2.total - t1.total;
biarkan penggunaan = 1 - menganggur / total;
if (persentase) penggunaan = (penggunaan * 100.0).toFixed(2) + "%";
pengembalian penggunaan;
}
/**
* Dapatkan informasi waktu sesaat CPU * @returns { Objek } Informasi CPU * pengguna <angka> Jumlah milidetik yang dihabiskan CPU dalam mode pengguna.
* bagus <angka> Jumlah milidetik yang dihabiskan CPU dalam mode bagus.
* sys <number> Jumlah milidetik yang dihabiskan CPU dalam mode sistem.
* idle <angka> Jumlah milidetik yang dihabiskan CPU dalam mode siaga.
* irq <angka> Jumlah milidetik yang dihabiskan CPU dalam mode permintaan interupsi.
*/
_getCPUInfo() {
const cpus = os.cpus();
misalkan user = 0, bagus = 0, sys = 0, idle = 0, irq = 0, total = 0;
untuk (biarkan cpu masuk cpu) {
const kali = CPU[cpu].kali;
pengguna += kali.pengguna;
bagus += kali.bagus;
sys += kali.sys;
menganggur += kali.menganggur;
irq += kali.irq;
}
total += pengguna + bagus + sys + idle + irq;
kembali {
pengguna,
ya,
menganggur,
total,
}
}
}
const cpuUsage = OSUtils baru().getCPUUsage({ persentase: benar });
console.log('cpuUsage: ', cpuUsage.then(data=>console.log(data))); // Komputer saya memiliki . Beban CPU (loadavg) mudah dipahami dan mengacu pada tertentu periode waktu. Jumlah proses yang menggunakan waktu CPU dan proses yang menunggu waktu CPU adalah rata-rata beban. Proses yang menunggu waktu CPU di sini mengacu pada proses yang menunggu untuk dibangunkan, tidak termasuk proses dalam keadaan menunggu.
Sebelum ini kita perlu mempelajari API node
os.loadavg()yang mengembalikan array yang berisi beban rata-rata 1, 5, dan 15 menit.
Rata-rata beban adalah ukuran aktivitas sistem yang dihitung oleh sistem operasi dan dinyatakan dalam desimal.
Rata-rata beban adalah konsep khusus Unix. Di Windows, nilai yang dikembalikan selalu [0, 0, 0]
Nilai ini digunakan untuk menggambarkan kesibukan sistem operasi saat ini. Secara sederhana, nilai ini dapat dipahami sebagai jumlah rata-rata tugas yang sedang digunakan dan menunggu untuk digunakan oleh CPU CPU per satuan waktu. Beban CPU terlalu tinggi, menunjukkan bahwa ada terlalu banyak proses. Di Node, hal ini mungkin tercermin dalam memulai proses baru berulang kali menggunakan modul Kota Terlarang.
const os = memerlukan('os');
//Jumlah thread CPU const length = os.cpus().length;
//Beban rata-rata dari CPU inti tunggal, mengembalikan
array yang berisi beban rata-rata 1, 5, dan 15 menit os.loadavg().map(load => load / length)
, jika tidak, Anda tidak dapat membacanya Pahami kode kami untuk mendapatkan indikator memori,
Fungsi ini mengembalikan 4 parameter, arti dan perbedaannya adalah sebagai berikut:
Gunakan kode berikut untuk mencetak penggunaan memori proses anak. Dapat dilihat bahwa rss kira-kira sama dengan RES dari perintah teratas. Selain itu, memori proses utama hanya 33M, lebih kecil dari memori proses anak, terlihat penggunaan memorinya dihitung secara mandiri.
var showMem = fungsi(){
var mem = proses.memoryUsage();
var format = fungsi(byte){
kembali (byte / 1024/1024).toFixed(2) + 'MB';
};
console.log('Proses: heapTotal ' + format(mem.heapTotal) + ' heapUsed ' + format(mem.heapUsed) + ' rss ' + format(mem.rss) + ' eksternal:' + format(mem.external) );
console.log('---------------------------------------------- --- ---------------');
}; Untuk Node, sekali terjadi kebocoran memori, tidak mudah untuk memecahkan masalah. Jika dimonitor memorinya hanya naik tapi tidak turun, maka pasti ada masalah kebocoran memori. Penggunaan memori yang sehat harus naik dan turun. Ketika akses besar, ia meningkat, dan ketika akses menurun, ia berkurang.
const os = require('os');
// Periksa penggunaan memori proses Node saat ini const { rss, heapUsed, heapTotal } = process.memoryUsage();
// Dapatkan memori bebas sistem const systemFree = os.freemem();
// Dapatkan total memori sistem const systemTotal = os.totalmem();
modul.ekspor = {
ingatan: () => {
kembali {
sistem: 1 - systemFree / systemTotal, // Tumpukan penggunaan memori sistem: heapUsed / headTotal, // Node penggunaan memori proses Node saat ini: rss / systemTotal, // Rasio penggunaan memori proses Node saat ini dari memori sistem}
}
} Pemantauan disk terutama memonitor penggunaan disk. Karena seringnya penulisan log, ruang disk secara bertahap habis. Jika disk tidak mencukupi, akan menyebabkan berbagai masalah pada sistem. Tetapkan batas atas penggunaan disk. Setelah penggunaan disk melebihi nilai peringatan, administrator server harus mengatur log atau membersihkan disk.
Kode berikut mengacu pada monitor mudah 3.0.
const { execSync } = require('child_process');
hasil const = execSync('df -P', { pengkodean: 'utf8'})
const baris = hasil.split('n');
metrik const = {};
baris.forEach(baris => {
if (baris.mulaiDengan('/')) {
const pertandingan = baris.pertandingan(/(d+)%s+(/.*$)/);
jika (cocok) {
tingkat const = parseInt(cocok[1] || 0);
const dipasang = cocok[2];
if (!mounted.startsWith('/Volume/') && !mounted.startsWith('/private/')) {
metrik[terpasang] = tarif;
}
}
}
});
console.log(metrik) Beban I/O terutama mengacu pada I/O disk. Ini mencerminkan situasi baca dan tulis pada disk. Untuk aplikasi yang ditulis oleh Node, yang sebagian besar ditujukan untuk layanan jaringan, kecil kemungkinannya beban I/O akan terlalu tinggi. Tekanan I/O dari banyak pembacaan berasal dari database .
Untuk mendapatkan indikator I/O, kita perlu memahami perintah Linux yang disebut iostat. Jika tidak diinstal, Anda perlu menginstalnya. Mari kita lihat mengapa perintah ini dapat mencerminkan indikator I/O
iostat -dx
Deskripsi properti
rrqm/s: Jumlah operasi baca gabungan per detik. Artinya, rmerge/s (berapa kali permintaan baca ke perangkat digabungkan per detik, dan sistem file akan menggabungkan permintaan untuk membaca blok yang sama) wrqm/s: Jumlah operasi penulisan gabungan per detik. Artinya, wmerge/s (berapa kali permintaan tulis ke perangkat digabungkan per detik) r/s: Jumlah pembacaan dari perangkat I/O yang diselesaikan per detik. Itu adalah rio/s w/s: Jumlah penulisan ke perangkat I/O yang diselesaikan per detik. Itu wio/s rsec/s: Jumlah sektor yang dibaca per detik. Itu adalah bagian wsec/s: Jumlah sektor yang ditulis per detik. yaitu wsect/s rkB/s: K byte dibaca per detik. Ini adalah setengah dari rsect/s karena ukuran setiap sektor adalah 512 byte. wkB/s: Jumlah K byte yang ditulis per detik. Ini adalah setengah dari wsect/s. avgrq-sz: Ukuran data rata-rata (sektor) per operasi I/O perangkat. avgqu-sz: Rata-rata panjang antrian I/O. menunggu: Waktu tunggu rata-rata (milidetik) untuk setiap operasi I/O perangkat. svctm: Waktu pemrosesan rata-rata (milidetik) dari setiap operasi I/O perangkat. %util: Berapa persentase satu detik yang digunakan untuk operasi I/O, yaitu persentase CPU yang dikonsumsi oleh IO.
Kita hanya perlu memantau %util.
Jika %util mendekati 100% , berarti terlalu banyak I Permintaan /O dibuat. Sistem I/O terisi penuh dan mungkin ada hambatan pada disk ini.
Jika menunggu jauh lebih besar dari svctm, berarti antrian I/O terlalu panjang dan waktu respons aplikasi menjadi lebih lambat. Jika waktu respons melebihi rentang yang dapat ditoleransi pengguna, Anda dapat mempertimbangkan untuk mengganti disk yang lebih cepat. menyesuaikan algoritma elevator kernel, dan mengoptimalkan aplikasi, atau meningkatkan CPU.
memantau waktu respons halaman Nodejs. Solusinya dipilih dari artikel blog guru Liao Xuefeng.
Baru-baru ini saya ingin memantau kinerja Nodejs. Mencatat dan menganalisis Log terlalu merepotkan. Cara paling sederhana adalah dengan mencatat waktu pemrosesan setiap permintaan HTTP dan mengembalikannya langsung di HTTP Response Header.
Mencatat waktu permintaan HTTP sangat sederhana. Artinya, mencatat stempel waktu saat menerima permintaan, dan mencatat stempel waktu lain saat merespons permintaan.
Namun, kode res.send() tersebar di berbagai file js, sehingga Anda tidak dapat mengubah setiap fungsi pemrosesan URL.
Ide yang benar adalah menggunakan middleware untuk mencapainya. Tetapi Nodejs tidak memiliki metode apa pun untuk mencegat res.send(), bagaimana cara memecahkannya?
Faktanya, selama kita sedikit mengubah pemikiran kita, meninggalkan metode OOP tradisional, dan melihat res.send() sebagai objek fungsi, pertama-tama kita dapat menyimpan fungsi pemrosesan asli res.send, dan kemudian mengganti res.send dengan fungsi pemrosesan asli kita. fungsi pemrosesan sendiri:
app.use (fungsi (req, res, next) {
//Rekam waktu mulai:
var exec_start_at = Tanggal.sekarang();
//Simpan fungsi pemrosesan asli:
var _send = res.kirim;
// Ikat fungsi handler kita sendiri:
res.kirim = fungsi () {
//Kirim Tajuk:
res.set('Waktu Eksekusi X', String(Tanggal.sekarang() - exec_start_at));
// Panggil fungsi pemrosesan asli:
return _send.apply(res, argumen);
};
Berikutnya();
}); Hanya dalam beberapa baris kode, stempel waktu selesai.
Tidak perlu memproses metode res.render() karena res.render() memanggil res.send() secara internal.
Saat memanggil fungsi apply(), penting untuk meneruskan objek res, jika tidak, this dari fungsi pemrosesan asli menunjuk ke tidak terdefinisi, yang secara langsung menyebabkan kesalahan.
Waktu respons halaman beranda yang diukur 9 milidetik
Glosarium:
QPS: Kueri Per Detik berarti "laju kueri per detik", yang merupakan jumlah kueri yang dapat ditanggapi oleh server. per detik , adalah ukuran berapa banyak lalu lintas yang ditangani server kueri tertentu dalam jangka waktu tertentu.
Di Internet, kinerja mesin yang berfungsi sebagai server sistem nama domain sering kali diukur dengan kecepatan kueri per detik.
TPS: singkatan dari TransactionsPerSecond, yaitu jumlah transaksi/detik. Ini adalah unit pengukuran hasil pengujian perangkat lunak. Transaksi mengacu pada proses di mana klien mengirimkan permintaan ke server dan server merespons. Klien memulai penghitungan waktu saat mengirimkan permintaan dan berakhir saat menerima respons server untuk menghitung waktu yang digunakan dan jumlah transaksi yang diselesaikan.
QPS vs TPS: QPS pada dasarnya mirip dengan TPS, tetapi perbedaannya adalah kunjungan ke suatu halaman membentuk TPS; tetapi permintaan halaman dapat menghasilkan beberapa permintaan ke server, dan server dapat menghitung permintaan ini sebagai " QPS". Misalnya, mengakses suatu halaman akan meminta server dua kali. Satu akses akan menghasilkan "T" dan dua "Q".
. Waktu respons: total waktu yang diperlukan untuk mengeksekusi permintaan dari awal hingga akhir ketika data respons diterima, yaitu waktu dari klien memulai permintaan hingga menerima hasil respons server.
Waktu respons RT (Waktu respons) adalah salah satu indikator terpenting suatu sistem. Nilai numeriknya secara langsung mencerminkan kecepatan sistem.
Jumlah konkurensi mengacu pada jumlah permintaan yang dapat ditangani sistem pada saat yang bersamaan. Hal ini juga mencerminkan kapasitas beban sistem.
Throughput (kapasitas menahan tekanan) sistem berkaitan erat dengan konsumsi permintaan CPU, antarmuka eksternal, IO, dll. Semakin tinggi konsumsi CPU untuk satu permintaan, semakin lambat antarmuka sistem eksternal dan kecepatan IO, serta semakin rendah kapasitas throughput sistem, dan sebaliknya.
Beberapa parameter penting dari throughput sistem: QPS (TPS), jumlah konkurensi, dan waktu respons.
QPS (TPS): (Query Per Second) Jumlah permintaan/transaksi per detik
Concurrency: Jumlah permintaan/transaksi yang diproses sistem dalam waktu bersamaan
Respon time: Umumnya, rata-rata waktu respons
dihitung setelah memahami maksud di atas tiga elemen. Hubungan di antara keduanya:
Mari kita pahami konsep di atas melalui sebuah contoh. Menurut aturan 80/20, jika 80% kunjungan harian terkonsentrasi pada 20% waktu, maka 20% waktu ini disebut waktu puncak.
1, 300w per hari PV pada satu mesin. Berapa banyak QPS yang dibutuhkan mesin ini?
(3000000 * 0,8) / (86400 * 0,2) = 139 (QPS)
2. Jika QPS suatu mesin adalah 58, berapa banyak mesin yang diperlukan untuk mendukungnya?
139/58 = 3
Pada titik ini, jika Anda melakukan arsitektur front-end dari proyek umum kecil dan menengah dan menerapkan layanan node Anda sendiri, Anda akan mengetahui berapa banyak mesin yang diperlukan untuk membentuk cluster untuk melaporkan ppt. Anda dapat menghitung nilai kasar dengan PV.
Kita perlu memahami stress test (kita perlu mengandalkan stress test untuk mendapatkan qps). Ambil perintah ab sebagai contoh:
format perintah:
ab [options] [http://]hostname[:port]/path
Common parameternya adalah sebagai berikut:
-n total permintaan Jumlah permintaan -c konkurensi Jumlah konkurensi -t batas waktu Jumlah detik maksimum untuk pengujian, yang dapat dianggap sebagai waktu tunggu permintaan -p postfile File berisi data yang memerlukan POST -T tipe konten Informasi header tipe konten yang digunakan oleh data POST Salin kode