Ich habe kürzlich etwas über die Überwachung von NodeJS gelernt. Obwohl ich nicht die Energie habe, eine einfache Version der Überwachung zu schreiben, kann ich nicht anders, als zu lernen, wie man diese Indikatoren erhält (nachdem ich viele Informationen konsultiert habe). Da es im heimischen Internet zu wenig Einführung in diesen Inhalt gibt, sortiere ich auch die Wissenspunkte zu Serverknoten, daher werde ich sie in diesem Artikel zusammenfassen und mit Ihnen teilen.
Bei einigen Indikatoren in diesem Artikel kann es zu Problemen kommen. Sie können diese Daten tatsächlich organisieren und in eine Überwachungsbibliothek schreiben und in Ihren eigenen kleinen und mittleren Projekten verwenden. Dann verfügt die Front-End-Reaktion über Tools wie Bizcharts und G2, und das Front-End zeichnet den großen Datenbildschirm selbst. Ich denke, dass die von esay monitor erfassten Datendimensionen nicht so umfassend sind wie unsere.
Die Leistungsengpässe von Servern sind normalerweise die folgenden:
-Auslastung und der CPU-Auslastung, die beide bis zu einem gewissen Grad die Auslastung einer Maschine widerspiegeln können.
Die CPU-Auslastung ist die CPU-Ressourcen, die durch laufende Programme belegt wird. Sie gibt an, wie der Computer zu einem bestimmten Zeitpunkt Programme ausführt. Je höher die Nutzungsrate, desto mehr Programme werden auf dem Computer ausgeführt, und umgekehrt. Der Auslastungsgrad steht in direktem Zusammenhang mit der Stärke der CPU. Lassen Sie uns zunächst die relevanten APIs und einige Terminologieerklärungen verstehen, die uns helfen, den Code zum Ermitteln der CPU-Auslastung zu verstehen.
os.cpus()gibt ein Array von Objekten zurück, die Informationen zu jedem logischen CPU-Kern enthalten.
model: eine Zeichenfolge, die das Modell des CPU-Kerns angibt.
Geschwindigkeit: Eine Zahl, die die Geschwindigkeit des CPU-Kerns in MHz angibt.
times: Ein Objekt mit den folgenden Eigenschaften:
HINWEIS: Der nice Wert gilt nur für POSIX. Auf Windows-Betriebssystemen ist der Wert von nice für alle Prozessoren immer 0.
Wenn Sie die Felder „Benutzer“ und „Nette“ sehen, sind einige Schüler über die Vorteile verwirrt, und ich auch, also habe ich mich sorgfältig nach ihrer Bedeutung erkundigt, bitte fahren Sie fort.
user gibt an, wie viel Zeit die CPU im Benutzermodus läuft.
Die Ausführung des Anwendungsprozesses ist in Benutzermodus und Kernelmodus unterteilt: Die CPU führt im Benutzermodus die eigene Codelogik des Anwendungsprozesses aus, normalerweise einige logische oder numerische Berechnungen . Die CPU führt vom Prozess initiierte Systemaufrufe im Kernelmodus aus, normalerweise als Reaktion zur Anforderung des Prozesses nach Ressourcen.
Ein Userspace-Programm ist jeder Prozess, der nicht Teil des Kernels ist. Shells, Compiler, Datenbanken, Webserver und Desktop-bezogene Programme sind allesamt User-Space-Prozesse. Wenn der Prozessor nicht im Leerlauf ist, ist es normal, dass die meiste CPU-Zeit für die Ausführung von User-Space-Prozessen aufgewendet wird.
Nice stellt den Anteil der Zeit dar, in der die CPU im Benutzermodus mit niedriger Priorität ausgeführt wird. Niedrige Priorität bedeutet, dass der Nice-Wert des Prozesses kleiner als 0 ist.
Derstellt den Anteil der Zeit dar, in der die CPU im Kernelmodus ausgeführt wird.
Im Allgemeinen sollte die CPU-Auslastung im Kernelmodus nicht zu hoch sein, es sei denn, der Anwendungsprozess initiiert eine große Anzahl von Systemaufrufen. Wenn der Wert zu hoch ist, bedeutet dies, dass der Systemaufruf lange dauert, beispielsweise bei häufigen E/A-Vorgängen.
Leerlauf gibt den Anteil der Zeit an, in der sich die CPU im Leerlaufzustand befindet und in der die CPU keine Aufgaben auszuführen hat.
irq stellt den Zeitanteil dar, den die CPU mit der Verarbeitung von Hardware-Interrupts verbringt.
Der Netzwerkkarten-Interrupt ist ein typisches Beispiel: Nachdem die Netzwerkkarte das Datenpaket empfangen hat, benachrichtigt sie die CPU über einen Hardware-Interrupt zur Verarbeitung. Wenn der Systemnetzwerkverkehr sehr stark ist, kann es zu einem erheblichen Anstieg der IRQ-Nutzung kommen.
Wenn der Benutzerstatus weniger als 70 %, der Kernelstatus weniger als 35 % und der Gesamtstatus weniger als 70 % beträgt, kann dies als fehlerfreier Status gezählt werden.
Das folgende Beispiel veranschaulicht die Verwendung der Methode os.cpus() in Node.js:
Beispiel 1:
// Node.js-Programm zur Demonstration des
//os.cpus()-Methode
// Betriebssystemmodul wird zugewiesen
const os = require('os');
// Werte von os.cpus() drucken
console.log(os.cpus()); Ausgabe:
[ { model:'Intel(R) Core(TM) i5-7200U CPU @ 2,50GHz',
Geschwindigkeit: 2712,
mal:
{ user:900000, nice:0, sys:940265, empty:11928546, irq:147046 } },
{ Modell: „Intel(R) Core(TM) i5-7200U CPU bei 2,50 GHz“,
Geschwindigkeit: 2712,
mal:
{ user:860875, nice:0, sys:507093, empty:12400500, irq:27062 } },
{ Modell: „Intel(R) Core(TM) i5-7200U CPU bei 2,50 GHz“,
Geschwindigkeit: 2712,
mal:
{ user:1273421, nice:0, sys:618765, empty:11876281, irq:13125 } },
{ Modell: „Intel(R) Core(TM) i5-7200U CPU bei 2,50 GHz“,
Geschwindigkeit: 2712,
mal:
{ user:943921, nice:0, sys:460109, empty:12364453, irq:12437 } } ] Das Folgende ist der Code zum Erhalten der CPU-Auslastung
const os = require('os');
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
Klasse OSUtils {
Konstruktor() {
this.cpuUsageMSDefault = 1000; //Standardzeitraum der CPU-Auslastung}
/**
* CPU-Auslastung für einen bestimmten Zeitraum abrufen* @param { Number } Options.ms [Zeitraum, der Standardwert ist 1000 ms, also 1 Sekunde]
* @param { Boolean } Options.percentage [true (als prozentuales Ergebnis zurückgegeben) |.
* @returns { Versprechen }
*/
async getCPUUsage(options={}) {
const that = this;
let { cpuUsageMS, Prozentsatz } = Optionen;
cpuUsageMS = cpuUsageMS ||. that.cpuUsageMSDefault;
const t1 = that._getCPUInfo(); // CPU-Informationen zum Zeitpunkt t1 waiting sleep(cpuUsageMS);
const t2 = that._getCPUInfo(); // CPU-Informationen zum Zeitpunkt t2 const empty = t2.idle - t1.idle;
const total = t2.total - t1.total;
Let Usage = 1 – Leerlauf / Gesamt;
if (Prozentsatz) Nutzung = (Nutzung * 100.0).toFixed(2) + „%“;
Rückgabenutzung;
}
/**
* Informationen zur momentanen CPU-Zeit abrufen * @returns { Object } CPU-Informationen * Benutzer <Nummer> Die Anzahl der Millisekunden, die die CPU im Benutzermodus verbracht hat.
* nice <Zahl> Die Anzahl der Millisekunden, die die CPU im Nice-Modus verbringt.
* sys <Zahl> Anzahl der Millisekunden, die die CPU im Systemmodus verbracht hat.
* empty <Zahl> Die Anzahl der Millisekunden, die die CPU im Leerlaufmodus verbracht hat.
* irq <Nummer> Die Anzahl der Millisekunden, die die CPU im Interrupt-Anforderungsmodus verbracht hat.
*/
_getCPUInfo() {
const cpus = os.cpus();
let user = 0, nice = 0, sys = 0, empty = 0, irq = 0, total = 0;
for (let cpu in cpus) {
const times = cpus[cpu].times;
Benutzer += times.user;
schön += mal.schön;
sys += times.sys;
im Leerlauf += times.idle;
irq += times.irq;
}
insgesamt += Benutzer + nett + sys + leer + irq;
zurückkehren {
Benutzer,
sys,
Leerlauf,
gesamt,
}
}
}
const cpuUsage = new OSUtils().getCPUUsage({percentage: true });
console.log('cpuUsage: ', cpuUsage.then(data=>console.log(data))); // Die CPU-Auslastung meines Computers (loadavg) ist leicht zu verstehen und bezieht sich auf einen bestimmten
Die Anzahl der Prozesse, die CPU-Zeit beanspruchen und auf CPU-Zeit warten, ist der Auslastungsdurchschnitt. Die auf CPU-Zeit wartenden Prozesse beziehen sich hier auf Prozesse, die darauf warten, aktiviert zu werden, mit Ausnahme von Prozessen im Wartezustand.
Zuvor müssen wir eine Knoten-API lernen.
os.loadavg()gibt ein Array zurück, das die durchschnittliche Last von 1, 5 und 15 Minuten enthält.
Der Lastdurchschnitt ist ein Maß für die Systemaktivität, das vom Betriebssystem berechnet und als Dezimalzahl ausgedrückt wird.
Der Lastdurchschnitt ist ein Unix-spezifisches Konzept. Unter Windows ist der Rückgabewert immer [0, 0, 0]
Er wird verwendet, um die aktuelle Auslastung des Betriebssystems zu beschreiben. Er kann einfach als die durchschnittliche Anzahl der Aufgaben verstanden werden, die die CPU verwendet und auf deren Verwendung wartet CPU pro Zeiteinheit. Die CPU-Auslastung ist zu hoch, was darauf hinweist, dass zu viele Prozesse in Node vorhanden sind. Dies kann sich darin widerspiegeln, dass immer wieder neue Prozesse mithilfe des Forbidden City-Moduls gestartet werden.
const os = require('os');
//Anzahl der CPU-Threads const length = os.cpus().length;
//Die durchschnittliche Auslastung einer Single-Core-CPU gibt ein Array zurück, das die durchschnittliche Auslastung von 1, 5 und 15 Minuten enthält. os.loadavg().map(load => load / length) Lassen Sie uns zunächst eine API erklären , sonst können Sie es nicht lesen. Verstehen Sie unseren Code zum Erhalten von Speicherindikatoren,
Diese Funktion gibt 4 Parameter zurück, die Bedeutung und Unterschiede sind wie folgt:
Verwenden Sie den folgenden Code, um die Speichernutzung eines untergeordneten Prozesses auszudrucken. Es ist ersichtlich, dass rss ungefähr dem RES des oberen Befehls entspricht. Darüber hinaus beträgt der Speicher des Hauptprozesses nur 33 MB, was kleiner ist als der Speicher des untergeordneten Prozesses. Es ist ersichtlich, dass ihre Speichernutzung unabhängig berechnet wird.
var showMem = function(){
var mem = process.memoryUsage();
var format = function(bytes){
return (Bytes / 1024 / 1024).toFixed(2) + 'MB';
};
console.log('Prozess: heapTotal ' + format(mem.heapTotal) + ' heapUsed ' + format(mem.heapUsed) + ' rss ' + format(mem.rss) + ' external:' + format(mem.external) );
console.log('------------------------------ --- --------------');
}; Sobald ein Speicherverlust auftritt, ist die Fehlerbehebung für Node nicht so einfach. Wenn überwacht wird, dass der Speicher nur steigt, aber nicht sinkt, muss ein Speicherverlustproblem vorliegen. Eine gesunde Speichernutzung sollte steigen und fallen. Wenn der Zugriff groß ist, steigt er, und wenn der Zugriff sinkt, verringert er sich.
const os = require('os');
// Überprüfen Sie die aktuelle Speichernutzung des Knotenprozesses const { rss, heapUsed, heapTotal } =process.memoryUsage();
// Systemfreien Speicher abrufen const systemFree = os.freemem();
// Den gesamten Systemspeicher abrufen const systemTotal = os.totalmem();
module.exports = {
Speicher: () => {
zurückkehren {
system: 1 - systemFree / systemTotal, // Systemspeicherauslastung heap: heapUsed / headTotal, // Aktueller Knotenprozessspeicherauslastung node: rss / systemTotal, // Aktueller Knotenprozessspeicherauslastungsanteil des Systemspeichers}
}
} Die Festplattenüberwachung überwacht hauptsächlich die Festplattennutzung. Aufgrund des häufigen Schreibens von Protokollen wird der Speicherplatz nach und nach verbraucht. Sobald die Festplatte nicht ausreicht, führt dies zu verschiedenen Problemen im System. Legen Sie eine Obergrenze für die Festplattennutzung fest. Sobald die Festplattennutzung den Warnwert überschreitet, sollte der Serveradministrator Protokolle organisieren oder die Festplatte bereinigen.
Der folgende Code bezieht sich auf Easy Monitor 3.0.
const { execSync } = require('child_process');
const result = execSync('df -P', { Kodierung: 'utf8'})
constlines = result.split('n');
const metric = {};
lines.forEach(line => {
if (line.startsWith('/')) {
const match = line.match(/(d+)%s+(/.*$)/);
if (match) {
const rate = parseInt(match[1] || 0);
const mount = match[2];
if (!montiert.startsWith('/Volumes/') && !montiert.startsWith('/private/')) {
metric[montiert] = rate;
}
}
}
});
console.log(metric) E/A-Last bezieht sich hauptsächlich auf Festplatten-E/A. Es spiegelt die Lese- und Schreibsituation auf der Festplatte wider. Bei von Node geschriebenen Anwendungen, die hauptsächlich für Netzwerkdienste bestimmt sind, ist es unwahrscheinlich, dass die E/A-Last von der Datenbank ausgeht .
Um I/O-Indikatoren zu erhalten, müssen wir einen Linux-Befehl namens iostat verstehen. Wenn er nicht installiert ist, müssen Sie ihn installieren. Schauen wir uns an, warum dieser Befehl die I/O-Indikatoren
iostat -dxwiderspiegeln kann
Eigenschaftsbeschreibung
rrqm/s: Die Anzahl der Zusammenführungslesevorgänge pro Sekunde. Das heißt, rmerge/s (die Häufigkeit, mit der Leseanforderungen an das Gerät pro Sekunde zusammengeführt werden und das Dateisystem Anforderungen zum Lesen desselben Blocks zusammenführt) wrqm/s: Die Anzahl der Merge-Schreibvorgänge pro Sekunde. Das heißt, wmerge/s (die Häufigkeit, mit der Schreibanfragen an das Gerät pro Sekunde zusammengeführt werden) r/s: Die Anzahl der pro Sekunde abgeschlossenen Lesevorgänge vom E/A-Gerät. Das ist Rio/s w/s: Die Anzahl der pro Sekunde abgeschlossenen Schreibvorgänge auf das E/A-Gerät. Das ist wio/s rsec/s: Anzahl der pro Sekunde gelesenen Sektoren. Das ist resect/s wsec/s: Anzahl der pro Sekunde geschriebenen Sektoren. d.h. wsect/s rkB/s: K Bytes, die pro Sekunde gelesen werden. Es ist die Hälfte von rsect/s, da jeder Sektor 512 Byte groß ist. wkB/s: Anzahl der K Bytes, die pro Sekunde geschrieben werden. Es ist die Hälfte von wsect/s. avgrq-sz: Durchschnittliche Datengröße (Sektoren) pro Geräte-E/A-Vorgang. avgqu-sz: Durchschnittliche Länge der E/A-Warteschlange. Warten: Die durchschnittliche Wartezeit (Millisekunden) für jeden Geräte-E/A-Vorgang. svctm: Durchschnittliche Verarbeitungszeit (Millisekunden) jedes Geräte-E/A-Vorgangs.%
util
: Wie viel Prozent einer Sekunde werden für E/A-Vorgänge verwendet,
d
/O-Anfragen werden generiert. Das E/A-System ist vollständig ausgelastet und es liegt möglicherweise ein Engpass auf dieser Festplatte vor.
Wenn „wait“ viel größer als „svctm“ ist, bedeutet dies, dass die E/A-Warteschlange zu lang ist und die Antwortzeit der Anwendung langsamer wird. Wenn die Antwortzeit den vom Benutzer tolerierbaren Bereich überschreitet, können Sie den Austausch einer schnelleren Festplatte in Betracht ziehen. Anpassen des Kernel-Elevator-Algorithmus und Optimieren der Anwendung oder Aktualisieren der CPU.
überwacht die Seitenantwortzeit von Nodejs. Die Lösung wurde aus dem Blog-Artikel von Lehrer Liao Xuefeng ausgewählt.
Kürzlich möchte ich die Leistung von Nodejs überwachen. Das Aufzeichnen und Analysieren von Protokollen ist zu mühsam. Die einfachste Möglichkeit besteht darin, die Verarbeitungszeit jeder HTTP-Anforderung aufzuzeichnen und sie direkt im HTTP-Antwortheader zurückzugeben.
Das Aufzeichnen der Zeit einer HTTP-Anfrage ist sehr einfach. Es bedeutet, einen Zeitstempel aufzuzeichnen, wenn die Anfrage empfangen wird, und einen weiteren Zeitstempel aufzuzeichnen, wenn auf die Anfrage geantwortet wird.
Allerdings ist der res.send()-Code auf verschiedene js-Dateien verteilt, sodass Sie nicht jede URL-Verarbeitungsfunktion ändern können.
Die richtige Idee besteht darin, Middleware zu verwenden, um dies zu erreichen. Aber Nodejs hat keine Methode zum Abfangen von res.send(), wie kann man das brechen?
Solange wir unsere Denkweise leicht ändern, die traditionelle OOP-Methode aufgeben und res.send () als Funktionsobjekt betrachten, können wir zunächst die ursprüngliche Verarbeitungsfunktion res.send speichern und dann res.send durch unsere ersetzen eigene Verarbeitungsfunktion:
app.use (function (req, res, next) {
//Startzeit aufzeichnen:
var exec_start_at = Date.now();
//Speichern Sie die ursprüngliche Verarbeitungsfunktion:
var _send = res.send;
// Binden Sie unsere eigene Handler-Funktion:
res.send = function () {
//Header senden:
res.set('X-Execution-Time', String(Date.now() - exec_start_at));
// Rufen Sie die ursprüngliche Verarbeitungsfunktion auf:
return _send.apply(res, arguments);
};
nächste();
}); In nur wenigen Codezeilen ist der Zeitstempel fertig.
Es besteht keine Notwendigkeit, die Methode res.render() zu verarbeiten, da res.render() intern res.send() aufruft.
Beim Aufruf der Funktion apply() ist es wichtig, das res-Objekt zu übergeben, da sonst das this der ursprünglichen Verarbeitungsfunktion auf undefiniert zeigt, was direkt zu einem Fehler führt.
Gemessene Antwortzeit der Homepage: 9 Millisekunden.
Glossar:
QPS: Abfragen pro Sekunde bedeutet „Abfragerate pro Sekunde“, also die Anzahl der Abfragen, auf die ein Server antworten kann pro Sekunde ist ein Maß dafür, wie viel Datenverkehr ein bestimmter Abfrageserver innerhalb eines bestimmten Zeitraums verarbeitet.
Im Internet wird die Leistung einer Maschine, die als Domain-Name-System-Server dient, häufig anhand der Abfragerate pro Sekunde gemessen.
TPS: ist die Abkürzung für TransactionsPerSecond, also die Anzahl der Transaktionen pro Sekunde. Es handelt sich um eine Maßeinheit für Softwaretestergebnisse. Eine Transaktion bezieht sich auf den Prozess, bei dem ein Client eine Anfrage an den Server sendet und der Server antwortet. Der Client beginnt mit der Zeitmessung, wenn er eine Anfrage sendet, und endet, wenn er die Antwort des Servers erhält, um die benötigte Zeit und die Anzahl der abgeschlossenen Transaktionen zu berechnen.
QPS vs. TPS: QPS ähnelt grundsätzlich TPS, der Unterschied besteht jedoch darin, dass ein Besuch einer Seite ein TPS bildet, eine Seitenanforderung jedoch mehrere Anforderungen an den Server generieren kann und der Server diese Anforderungen als „QPS“ zählen kann. Wenn Sie beispielsweise auf eine Seite zugreifen, wird der Server zweimal angefordert. Bei einem Zugriff werden ein „T“ und zwei „Q“ generiert.
. Antwortzeit: Die Gesamtzeit, die zum Ausführen einer Anfrage vom Anfang bis zum Ende benötigt wird, wenn die Antwortdaten empfangen werden, dh die Zeit vom Initiieren der Anfrage durch den Client bis zum Empfang des Serverantwortergebnisses.
Die Reaktionszeit RT (Reaktionszeit) ist einer der wichtigsten Indikatoren eines Systems. Ihr numerischer Wert spiegelt direkt die Geschwindigkeit des Systems wider.
Die Anzahl der Parallelitäten bezieht sich auf die Anzahl der Anfragen, die das System gleichzeitig verarbeiten kann. Dies spiegelt auch die Auslastungskapazität des Systems wider.
Der Durchsatz (Druckbelastbarkeit) des Systems hängt eng mit dem CPU-Verbrauch von Anforderungen, externen Schnittstellen, E/A usw. zusammen. Je höher der CPU-Verbrauch einer einzelnen Anfrage ist, desto langsamer sind die externe Systemschnittstelle und die E/A-Geschwindigkeit und desto geringer ist die Durchsatzkapazität des Systems und umgekehrt.
Mehrere wichtige Parameter des Systemdurchsatzes: QPS (TPS), Anzahl der Parallelitäten und Antwortzeit.
QPS (TPS): (Abfrage pro Sekunde) Anzahl der Anfragen/Transaktionen pro Sekunde
Parallelität: Anzahl der gleichzeitig vom System verarbeiteten Anfragen/Transaktionen
Antwortzeit: Im Allgemeinen
wird die durchschnittliche Antwortzeit berechnet, nachdem die Bedeutung der oben genannten Punkte verstanden wurde drei Elemente. Die Beziehung zwischen ihnen:
Lassen Sie uns die oben genannten Konzepte anhand eines Beispiels verstehen. Wenn sich gemäß der 80/20-Regel 80 % der täglichen Besuche auf 20 % der Zeit konzentrieren, werden diese 20 % der Zeit als Spitzenzeit bezeichnet.
1, 300 W pro Tag PV sind auf einer einzelnen Maschine. Wie viele QPS benötigt diese Maschine?
(3000000 * 0,8) / (86400 * 0,2) = 139 (QPS)
2. Wenn die QPS einer Maschine 58 beträgt, wie viele Maschinen werden benötigt, um sie zu unterstützen?
139/58 = 3
Wenn Sie an diesem Punkt die Front-End-Architektur allgemeiner kleiner und mittlerer Projekte erstellen und Ihre eigenen Knotendienste bereitstellen, wissen Sie, wie viele Maschinen erforderlich sind, um einen Cluster zu bilden, um ppt zu melden. Mit PV kann man einen groben Wert berechnen.
Wir müssen den Stresstest verstehen (wir müssen uns auf den Stresstest verlassen, um qps zu erhalten: Befehlsformat
:
ab [Optionen] [http://]Hostname[:Port]/Pfad
Allgemein)
.Die Parameter lauten wie folgt:
-n Anfragen insgesamt Anzahl der Anfragen -c Parallelität Anzahl der Parallelitäten -t Zeitlimit Die maximale Anzahl von Sekunden für den Test, die als Timeout-Zeit der Anfrage betrachtet werden kann -p Postfile Datei mit Daten, die POST erfordern -T content-type Inhaltstyp-Header-Informationen, die von POST-Daten verwendet werden. Code kopieren