Warum brauchen Sie eine Leistungsüberwachung? Lassen Sie uns über die Leistungsüberwachung von Node.j sprechen

Warum benötigen Sie eine Leistungsüberwachung? Dieser Artikel führt Sie durch die Leistungsüberwachung von Node.jsIch hoffe, er wird Ihnen hilfreich sein!

Warum Leistungsüberwachung erforderlich ist

KnotenAls serverseitige Laufzeit für Javascript bereichert es die Anwendungsszenarien von Javascript erheblich.

Aber die Node.js-Laufzeit selbst ist eine Black Box. Wir können den Status der Laufzeit nicht erkennen und es ist auch schwierig, Online-Probleme zu reproduzieren. Daher ist die Leistungsüberwachung der Grundstein für den „normalen Betrieb“ von Node.js-Anwendungen. Es können nicht nur jederzeit verschiedene Laufzeitindikatoren überwacht werden, sondern es kann auch bei der Behebung ungewöhnlicher Szenarioprobleme hilfreich sein.

Komponenten

Die Leistungsüberwachung kann in zwei Teile unterteilt werden:

Erfassung und Anzeige von Leistungsindikatoren

• Daten auf Prozessebene: CPU, Speicher, Heap, GC usw.
  Daten auf Systemebene : Festplattenbelegung, E/A-Last, TCP/UDP-Verbindungsstatus usw.
  • Daten der Anwendungsschicht: QPS, langsames HTTP, Verbindungsprotokolle zur Geschäftsverarbeitung usw.
  • Erfassung und Analyse von Leistungsdaten
• Heapsnapshot : Heap-Speicher-Snapshot
  Cpuprofile: CPU-Snapshot
  • Coredump: Snapshot des Anwendungsabsturzes
  Schemavergleich

Sie können die Vor- und Nachteile der drei aktuellen Mainstream-Node.js-Leistungsüberwachungslösungen sehen von In der obigen Abbildung finden Sie im Folgenden eine kurze Einführung in die Zusammensetzung dieser drei Lösungen:

Prometheus

• Prom-Client

  ist die NodeJS-Implementierung von Prometheus, die zum Sammeln von Leistungsindikatoren verwendet wird.
  • grafana ist ein Visualisierungsplattform zur Anzeige verschiedener Datendiagramme, die den Prometheus-Zugriff unterstützen
  • Es werden nur andere Snapshot-Tools benötigt, um Probleme zu beheben und einen geschlossenen Regelkreis zu bilden.
  • AliNode

• alinode ist eine Erweiterung, die mit offiziellen Nodejs kompatibel ist. Zur Laufzeit werden einige zusätzliche Funktionen bereitgestellt:

  • v8s Laufzeitspeicherstatusüberwachung
    libuvs Laufzeitstatusüberwachung
    • Online-Fehlerdiagnosefunktionen: Heap-Snapshot, CPU-Profil, GC-Trace usw.
    agenthub
  ist ein residenter Prozess, der zum Sammeln von Leistungsindikatoren und Berichten verwendet wird

  • Es integriert agentx

    +
    commdx
    • , ein praktisches Tool
    Der gesamte Prozess bildet einen geschlossenen Kreislauf aus Überwachung, Anzeige, Snapshot und Analyse, und der Zugriff ist bequem und einfach, aber es gibt immer noch Risiken bei der Erweiterung der Laufzeit. Easy-Monitor. xprofiler ist für die Echtzeit-Laufzeit-Statusabtastung und -Ausgabe verantwortlich Leistungsprotokolle (d. h. die Erfassung von Leistungsdaten)
  • Implementieren Sie den Sampler ://img.php.cn/upload/image/622/771/329/ 166021971134727Warum brauchen Sie eine Leistungsüberwachung? Lassen Sie uns über die Leistungsüberwachung von Node.j sprechen" title="166021971134727Warum brauchen Sie eine Leistungsüberwachung? Lassen Sie uns über die Leistungsüberwachung von Node.j sprechen" alt="2.png"/>
    Die CPU-Verbrauchsdaten des aktuellen Prozesses können kann über process.cpuUsage() abgerufen werden. Die Einheit des Rückgabewerts ist Mikrosekunden. Benutzer: Die vom Prozess selbst während der Ausführung verbrauchte CPU-Zeit. System: Die vom System verbrauchte CPU-Zeit wenn der Prozess ausgeführt wird .png" title="166021971753417Warum brauchen Sie eine Leistungsüberwachung? Lassen Sie uns über die Leistungsüberwachung von Node.j sprechen" alt="3.png"/>
  über process.memoryUsage ()Sie können die Speicherzuordnungsdaten des aktuellen Prozesses abrufen. Die Einheit der Rückgabewert ist Bytes.

• rss: residenter Speicher, die vom Knotenprozess zugewiesene Gesamtspeichergröße. heapTotal: die von v8 beantragte Heap-Speichergröße.

  heapUsed: die von v8 verwendete Heap-Speichergröße Von C++ belegte Größe, verwaltet von v8
  • arrayBuffers: Die Speichergröße, die ArrayBuffer
  • zugewiesen ist

    Wie Sie auf dem Bild oben sehen können, enthält rss Codesegmente (Code Segment), Stapelspeicher (Stack) und Heapspeicher ( Heap)rss包含代码段(Code Segment)、栈内存(Stack)、堆内存(Heap)

    • Code Segment：存储代码段
    • Stack：存储局部变量和管理函数调用
    • Heap：存储对象、闭包、或者其他一切

    Heap

    通过v8.getHeapStatistics()和v8.getHeapSpaceStatistics()可以获取v8堆内存和堆空间的分析数据，下图展示了v8的堆内存组成分布：

    

    堆内存空间先划分为空间（space），空间又划分为页（page），内存按照1MB对齐进行分页。

    • New Space：新生代空间，用来存放一些生命周期比较短的对象数据，平分为两个空间（空间类型为semi space）：from space，to space

      • 晋升条件：在New space中经过两次GC依旧存活

    • Old Space：老生代空间，用来存放New Space晋升的对象

    • Code Space：存放v8 JIT编译后的可执行代码

    • Map Space：存放Object指向的隐藏类的指针对象，隐藏类指针是v8根据运行时记录下的对象布局结构，用于快速访问对象成员

    • Large Object Space：用于存放大于1MB而无法分配到页的对象

    GC

    v8的垃圾回收算法分为两类：

    • Major GC：使用了Mark-Sweep-Compact算法，用于老生代的对象回收
    • Minor GC：使用了Scavenge算法，用于新生代的对象回收

    Scavenge

    

    前提：New space分为from和to两个对象空间

    触发时机：当New space空间满了

    步骤：

    • 在from space中，进行宽度优先遍历

    • 发现存活（可达）对象

      • 已经存活过一次（经历过一次Scavange），晋升到Old space
      • 其他的复制到to space中

    • 当复制结束时，to space中只有存活的对象，from space就被清空了

    • 交换from space和to space，开始下一轮Scavenge

    适用于回收频繁，内存不大的对象，典型的空间换时间的策略，缺点是浪费了多一倍的空间

    Mark-Sweep-Compact

    

    三个步骤：标记、清除、整理

    触发时机：当Old space空间满了

    步骤：

    • Marking（三色标记法）

      • 白色：代表可回收对象
      • 黑色：代表不可回收对象，且其所产生的引用都已经扫描完毕
      • 灰色：代表不可回收对象，且其所产生的引用还没扫描完
      • 将V8根对象直接引用的对象放进一个marking queue（显式栈）中，并将这些对象标记为灰色
      • 从这些对象开始做深度优先遍历，每访问一个对象，将该对象从marking queue pop出来，并标记为黑色
      • 然后将该对象引用下的所有白色对象标记为灰色，push到marking queue
      • Code-Segment: speichert Codesegmente
      • Stack: speichert lokale Variablen und verwaltet Funktionsaufrufe
      Heap: speichert Objekte, Abschlüsse oder alles andere

    • Heap

      V8-Heap-Speicher und Heap-Speicherplatz können über v8.getHeapStatistics() und v8.getHeapSpaceStatistics() Analysedaten, die folgende Abbildung zeigt die Heap-Speicherzusammensetzungsverteilung von Version 8:

      
      • Der Heap-Speicherplatz wird zunächst in Leerzeichen unterteilt, und der Speicherplatz wird entsprechend der 1-MB-Ausrichtung in Seiten unterteilt.
    Neuer Raum: Raum der neuen Generation, der zum Speichern einiger Objektdaten mit einem relativ kurzen Lebenszyklus verwendet wird und in zwei Räume unterteilt ist (der Raumtyp ist semi space): from space, <code>to space

    • Beförderungsbedingungen: Überleben nach zwei GCs im New Space immer noch🎜🎜🎜🎜🎜Old Space: Space der alten Generation, der zum Speichern von New Space-Code verwendet wird >Heraufgestuftes Objekt🎜🎜🎜🎜Code Space: Speichert den von v8 JIT kompilierten ausführbaren Code🎜🎜🎜🎜Map Space: Speichert das Zeigerobjekt der versteckten Klasse, auf die Object zeigt. Der Zeiger der versteckten Klasse ist das von v8 aufgezeichnete Objekt die Laufzeit-Layoutstruktur für schnellen Zugriff auf Objektmitglieder🎜🎜🎜🎜Großer Objektraum: Wird zum Speichern von Objekten verwendet, die größer als 1 MB sind und nicht Seiten zugewiesen werden können🎜🎜🎜<h3 data-id="heading-8"><strong>GC strong></strong></h3>Die Garbage-Collection-Algorithmen von 🎜v8 sind in zwei Kategorien unterteilt: 🎜🎜🎜Major GC: Verwendet den <code>Mark-Sweep-Compact-Algorithmus für das Recycling von Objekten der alten Generation 🎜🎜Minor GC: Verwendet den Scavenge-Algorithmus für das Objektrecycling in der neuen Generation🎜🎜

      Scavenge

      🎜🎜🎜Voraussetzung: Neuer Bereich ist in zwei Objektbereiche unterteilt: <code>von und bis🎜🎜Auslösezeit: wenn der Neuer Bereich-Bereich voll ist🎜🎜Schritte: 🎜🎜🎜🎜Führen Sie in aus dem Weltraum eine Breitendurchquerung 🎜🎜🎜🎜 durch und stellen Sie fest, dass das überlebende (erreichbare) Objekt 🎜🎜🎜 einmal überlebt hat (einmal Scavange erlebt hat) und zu Altes Leerzeichen🎜🎜Andere werden nach in Leerzeichen kopiert 🎜🎜🎜🎜🎜Wenn der Kopiervorgang endet, gibt es nur noch überlebende Objekte in in Leerzeichen, from space wird gelöscht🎜🎜🎜🎜Tausch from space und to space und starte die nächste Runde von Scavenge🎜🎜 🎜 🎜Geeignet für Objekte mit häufigem Recycling und kleinem Speicher. Es handelt sich um eine typische Raum-für-Zeit-Strategie. Der Nachteil besteht darin, dass doppelt so viel Platz verschwendet wird🎜

      Mark-Sweep-Compact

      🎜🎜🎜Drei Schritte: markieren, löschen, organisieren🎜🎜Auslösezeit: wenn Alter Speicherplatz voll ist🎜🎜Schritte: 🎜🎜🎜🎜 Markierung (dreifarbige Markierungsmethode)🎜🎜🎜Weiß: Stellt recycelbare Objekte dar.🎜🎜Schwarz: Stellt nicht recycelbare Objekte dar, und die von ihnen generierten Referenzen wurden gescannt.🎜🎜Grau: Stellt nicht recycelbare Objekte und die von generierten Referenzen dar Sie wurden noch nicht gescannt. Nach dem Scannen legen Sie die Objekte, auf die direkt vom V8-Stammobjekt verwiesen wird, in eine Markierungswarteschlange (expliziten Stapel) und markieren Sie diese Objekte als grau. Beginnen Sie mit der Tiefendurchquerung Von diesen Objekten aus jedes Mal, wenn Sie auf ein Objekt zugreifen, das Objekt aus der Markierungswarteschlange pop entfernen und es als schwarz markieren 🎜🎜 Markieren Sie dann alle weißen Objekte unter der Objektreferenz als grau, Push in die Markierungswarteschlange usw., bis alle Objekte auf dem Stapel entfernt sind. In der alten Generation sind nur noch zwei Objekte übrig: schwarz (nicht-). recycelbar) und weiß (recycelbar). PS: Wenn ein Objekt zu groß ist, um auf den Stapel geschoben zu werden, behält v8 das Objekt in Grau und überspringt es, wodurch der gesamte Stapel als überfüllt markiert wird Wenn es gelöscht wird, wird es erneut überquert, was einen zusätzlichen Scan des Heaps erfordert. Das Löschen weißer Objekte führt dazu, dass der Speicherplatz diskontinuierlich wird
      • Da Sweep dazu führt, dass der Speicherraum diskontinuierlich ist, ist es für neue Objekte nicht förderlich, in den GC einzutreten Der freigegebene Speicherplatz wird kontinuierlich und vollständig sein
      • Obwohl es das Problem der Speicherfragmentierung lösen kann, erhöht es die Pausenzeit (langsame Ausführungsgeschwindigkeit)Old space的一端，这样清除出来的空间就是连续完整的
      • 虽然可以解决内存碎片问题，但是会增加停顿时间（执行速度慢）
      • 在空间不足以对新生代晋升过来的对象进行分配时才使用mark-compact

    Stop-The-World

    在最开始v8进行垃圾回收时，需要停止程序的运行，扫描完整个堆，回收完内存，才会重新运行程序。这种行为就叫全停顿（Stop-The-World）

    虽然新生代活动对象较小，回收频繁，全停顿，影响不大，但是老生代存活对象多且大，标记、清理、整理等造成的停顿就会比较严重。

    优化策略

    • 增量回收（Incremental Marking）：在Marking阶段，当堆达到一定大小时，开始增量GC，每次分配了一定量的内存后，就暂停运行程序，做几毫秒到几十毫秒的marking，然后恢复程序的运行。

    这个理念其实有点像React框架中的Fiber架构，只有在浏览器的空闲时间才会去遍历Fiber Tree执行对应的任务，否则延迟执行，尽可能少地影响主线程的任务，避免应用卡顿，提升应用性能。

    • 并发清除（Concurrent Sweeping）：让其他线程同时来做 sweeping，而不用担心和执行程序的主线程冲突
    • 并行清除（Parallel Sweeping）：让多个 Sweeping 线程同时工作，提升 sweeping 的吞吐量，缩短整个 GC 的周期

    空间调整

    由于v8对于新老生代的空间默认限制了大小

    • New space 默认限制：64位系统为32M，32位系统为16M
    • Old space 默认限制：64位系统为1400M，32位系统为700M

    因此node提供了两个参数用于调整新老生代的空间上限

    • --max-semi-space-size：设置New Space空间的最大值
    • --max-old-space-size：设置Old Space空间的最大值

    查看GC日志

    node也提供了三种查看GC日志的方式：

    • --trace_gc：一行日志简要描述每次GC时的时间、类型、堆大小变化和产生原因
    • --trace_gc_verbose：展示每次GC后每个V8堆空间的详细状况
    • --trace_gc_nvp：每次GC的详细键值对信息，包含GC类型，暂停时间，内存变化等

    由于GC日志比较原始，还需要二次处理，可以使用AliNode团队开发的v8-gc-log-parser

    快照工具

    Heapsnapshot

    对于运行程序的堆内存进行快照采样，可以用来分析内存的消耗以及变化

    生成方式

    生成.heapsnapshot文件有以下几种方式：

    • 使用heapdump

    

    • 使用v8的heap-profile

    

    • 使用nodejs内置的v8模块提供的api

      • v8.getHeapSnapshot()

      

      • v8.writeHeapSnapshot(fileName)

      

    • 使用v8-profiler-next

    

    分析方法

    生成的.heapsnapshot

    Verwenden Sie mark-compact nur, wenn nicht genügend Speicherplatz vorhanden ist, um von der neuen Generation hochgestufte Objekte zuzuweisen

  

Stop-The-World

Wenn v8 zum ersten Mal die Speicherbereinigung durchführt, muss sie gestoppt werden Wenn das Programm ausgeführt wird, scannen Sie den gesamten Heap und recyceln Sie den Speicher. Das Programm wird erneut ausgeführt. Dieses Verhalten wird als Punkt (Stop-The-World) bezeichnet. 🎜🎜Obwohl die aktiven Objekte in der neuen Generation klein sind und häufig recycelt werden, hat der Punkt nur geringe Auswirkungen, jedoch auf die überlebenden Objekte in der alten Generation Es gibt viele und große Pausen, die durch Markieren, Reinigen, Ordnen usw. verursacht werden. 🎜

Optimierungsstrategie

🎜🎜Inkrementelle Markierung: Wenn der Heap in der Markierungsphase eine bestimmte Größe erreicht, beginnt die Inkrementierung mit der GC Er weist eine bestimmte Menge an Speicher zu, unterbricht die Ausführung des Programms, führt eine Markierung für einige Millisekunden bis mehrere zehn Millisekunden durch und setzt dann die Ausführung des Programms fort. 🎜🎜Dieses Konzept ähnelt tatsächlich der Fiber-Architektur im React-Framework. Nur während der freien Zeit des Browsers wird der Fiber-Baum durchlaufen, um die entsprechenden Aufgaben auszuführen Vermeiden Sie Anwendungsverzögerungen und verbessern Sie die Anwendungsleistung. 🎜🎜🎜Gleichzeitiges Sweeping: Lassen Sie andere Threads das Sweeping gleichzeitig durchführen, ohne sich Gedanken über Konflikte mit dem Hauptthread des ausführenden Programms machen zu müssen. 🎜🎜Paralleles Sweeping: Lassen Sie mehrere Sweeping-Threads gleichzeitig arbeiten, um den Sweeping-Durchsatz zu verbessern und die Zeit zu verkürzen gesamter GC-Zyklus🎜

Speicherplatzanpassung

🎜Weil v8 die Größe des Speicherplatzes der neuen und alten Generation standardmäßig begrenzt 🎜🎜 🎜Neuer Speicherplatz Standardlimit: 32 MB für 64-Bit-System, 16 MB für 32-Bit-System 🎜🎜Alter Speicherplatz Standardlimit: 1400 MB für 64-Bit-System, 1400 MB für 32 -Bit-System 700M🎜🎜Daher stellt node zwei Parameter zum Anpassen der oberen Speicherplatzgrenze der neuen und alten Generation bereit🎜🎜🎜--max-semi-space-size: Legen Sie den Maximalwert von <code>New Space fest. space🎜🎜--max-old-space-size: Legen Sie den Maximalwert von Old Space fest. code> space🎜<h4 data-id="heading-14"><strong>GC-Protokolle anzeigen</strong></h4>🎜<code>node bietet außerdem drei Möglichkeiten, GC anzuzeigen Protokolle: 🎜 🎜🎜--trace_gc: Eine Protokollzeile beschreibt kurz die Zeit, den Typ, die Heap-Größenänderungen und die Ursachen jedes GC. 🎜🎜--trace_gc_verbose: Zeigt die Ergebnisse jedes GC Detaillierter Status jedes V8-Heap-Speicherplatzes 🎜🎜--trace_gc_nvp: Detaillierte Informationen zu Schlüssel-Wert-Paaren jedes GC, einschließlich GC-Typ, Pausenzeit, Speicheränderungen usw. 🎜🎜Aufgrund des GC-Protokolls ist es relativ primitiv und erfordert eine sekundäre Verarbeitung. Sie können v8-gc-log-parser🎜

Snapshot-Tool

Heapsnapshot

🎜Snapshot-Sampling des Heap-Speichers des laufenden Programms kann zur Analyse verwendet werden Speicherverbrauch und Änderungen🎜

Generierungsmethode

🎜Es gibt mehrere Möglichkeiten, .heapsnapshot-Dateien zu generieren: 🎜🎜 🎜🎜Verwenden Sie heapdump🎜🎜🎜🎜🎜🎜🎜Mit v8heap-profile🎜🎜🎜🎜🎜🎜🎜Verwenden Sie die von v8 bereitgestellte API in nodejs integriertes Modul🎜🎜🎜🎜v8.getHeapSnapshot()🎜🎜🎜🎜🎜🎜🎜v8.writeHeapSnapshot(fileName)🎜🎜🎜🎜🎜🎜🎜Verwenden Sie v8-profiler-next🎜🎜🎜🎜

Analysemethode

🎜Die generierte .heapsnapshot-Datei kann in den Speicher der Chrome Devtools-Symbolleiste hochgeladen werden. Nach Auswahl wird das Ergebnis angezeigt wie unten gezeigt angezeigt: 🎜🎜🎜🎜

Die Standardansicht ist die Ansicht Zusammenfassung. Hier müssen wir auf die beiden Spalten ganz rechts achten: Flache Größe und Beibehaltene GrößeSummary视图，在这里我们要关注最右边两栏：Shallow Size 和 Retained Size

• Shallow Size：表示该对象本身在v8堆内存分配的大小
• Retained Size：表示该对象所有引用对象的Shallow Size之和

当发现Retained Size特别大时，该对象内部可能存在内存泄漏，可以进一步展开去定位问题

还有Comparison视图是用于比较分析两个不同时段的堆快照，通过Delta列可以筛选出内存变化最大的对象

Cpuprofile

对于运行程序的CPU进行快照采样，可以用来分析CPU的耗时及占比

生成方式

生成.cpuprofile文件有以下几种方式：

• v8-profiler（node官方提供的工具，不过已经无法支持node v10以上的版本，并不再维护）
• v8-profiler-next（国人维护版本，支持到最新node v18，持续维护中）

这是采集5分钟的CPU Profile样例

分析方法

生成的.cpuprofile文件，可以在Chrome devtools工具栏的Javascript Profiler（不在默认tab，需要在工具栏右侧的更多中打开显示），选择上传文件后，展示结果如下图：

默认的视图是Heavy视图，在这里我们看到有两栏：Self Time和Total Time

• Self Time：代表此函数本身（不包含其他调用）的执行耗时
• Total Time：代表此函数（包含其他调用函数）的总执行耗时

当发现Total Time和Self Time偏差较大时，该函数可能存在耗时比较多的CPU密集型计算，也可以展开进一步定位排查

Codedump

当应用意外崩溃终止时，系统会自动记录下进程crash掉那一刻的内存分配信息，Program Counter以及堆栈指针等关键信息来生成core文件

生成方式

生成.core文件的三种方法：

• ulimit -c unlimited打开内核限制
• node --abort-on-uncaught-exceptionnode启动添加此参数，可以在应用出现未捕获的异常时也能生成一份core文件
• gcore <pid></pid>手动生成core文件

分析方法

获取.core文件后，可以通过mdb、gdb、lldb等工具实现解析诊断实际进程crash的原因

• llnode `which node` -c /path/to/core/dump

案例分析

观察

从监控可以观察到堆内存在持续上升，因此需要堆快照进行排查

分析

根据heapsnapshot可以分析排查到有一个newThing的对象一直保持着比较大的内存

排查

从代码中可以看到虽然unused方法没有调用，但是newThing对象是引用自theThing，导致其一直存在于replaceThing

• Shallow Size: Gibt die Größe des Objekts selbst an, das im v8-Heap-Speicher zugewiesen ist
• Retained Size: Gibt den Shallow an aller referenzierten Objekte des Objekts Sizesum

Wenn festgestellt wird, dass Retained Size besonders groß ist, liegt möglicherweise ein Speicherverlust im Objekt vor. und Sie können weiter expandieren, um das Problem zu lokalisieren

Außerdem wird die Ansicht „code>Vergleich

zum Vergleichen und Analysieren von Heap-Snapshots zweier verschiedener Zeiträume verwendet. Die Spalte Delta kann zum Filtern verwendet werden Herausfinden der Objekte mit den größten Speicheränderungen

Cpuprofile🎜🎜🎜 führt Snapshot-Sampling der 🎜CPU🎜 durch, auf der das Programm ausgeführt wird, was zur Analyse der CPU-Zeit und des CPU-Anteils🎜🎜Generation method🎜🎜Generation.cpuprofile

-Dateien sind auf folgende Weise verfügbar: 🎜

• v8-profiler (ein offiziell von Node bereitgestelltes Tool, das jedoch Node v10 oder nicht mehr unterstützt oben und wird nicht mehr gepflegt)
• v8-profiler-next (Chinesische Wartungsversion, unterstützt den neuesten Knoten v18, kontinuierliches Wartungsmedium)

🎜Dies ist ein 5-minütiges CPU-Profilbeispiel 🎜🎜🎜

🎜Analysemethode🎜

🎜generierte .cpuprofileDatei, Sie können zu Javascript Profiler in der Chrome-Devtools-Symbolleiste gehen (nicht auf der Standardregisterkarte, Sie benötigen). , um die Anzeige unter „Mehr“ auf der rechten Seite der Symbolleiste zu öffnen. Nach der Auswahl zum Hochladen der Datei sieht das Anzeigeergebnis wie folgt aus: 🎜🎜 🎜🎜Standardansicht Es ist die Heavy-Ansicht. Hier sehen wir, dass es zwei gibt Spalten: Selbstzeit und Gesamtzeit🎜

• Selbstzeit: stellt die Ausführungszeit dieser Funktion selbst dar (mit Ausnahme anderer Aufrufe). )
• Gesamtzeit: stellt die Gesamtausführungszeit dieser Funktion dar (einschließlich anderer aufrufender Funktionen)

🎜Wenn festgestellt wird, dass die Abweichung zwischen Gesamtzeit und Selbstzeit sind groß, die Funktion kann CPU-intensive Berechnungen haben, die viel Zeit in Anspruch nehmen. Sie können auch weitere Fehlerbehebungen durchführen🎜

🎜Codedump🎜🎜🎜Wenn die Anwendung abstürzt und unerwartet beendet wird, zeichnet das System automatisch die Speicherzuordnungsinformationen, den Programmzähler und den Stapel zum Zeitpunkt des Prozessabsturzes auf. Zeiger und andere wichtige Informationen zum Generieren von Kerndateien🎜🎜Generierungsmethoden🎜🎜Drei Möglichkeiten, .core-Dateien zu generieren:🎜

• ulimit -c unlimitedKernel-Grenzwerte aktivieren
• node --abort-on-uncaught-ExceptionFügen Sie diesen Parameter beim Starten des Knotens hinzu, der in der Anwendung verwendet werden kann Eine Kerndatei kann wird auch generiert, wenn eine nicht abgefangene Ausnahme auftritt
• gcore <pid></pid>Generieren Sie die Kerndatei manuell

🎜Analysemethode🎜

🎜Nach Erhalt der .core-Datei können Sie mdb, gdb, lldb und andere Tools verwenden, um die Ursache des tatsächlichen Prozessabsturzes zu analysieren und zu diagnostizieren🎜

llnode `which node` -c /path/to/core/dump

🎜Fallanalyse🎜 h2>

🎜Beobachtung🎜🎜🎜🎜🎜Aus der Überwachung kann beobachtet werden, dass der Heap-Speicher weiter zunimmt, sodass zur Fehlerbehebung Heap-Snapshots erforderlich sind🎜

🎜Analyse🎜🎜 🎜🎜🎜gemäßheapsnapshot kann analysiert und überprüft werden, um herauszufinden, dass ein Objekt von newThing immer einen relativ großen Speicher beibehalten hat🎜

🎜Fehlerbehebung🎜🎜🎜🎜🎜Sie können es dem Code entnehmen. Obwohl die Methode unused nicht aufgerufen wird, wird von theThing auf das Objekt newThing verwiesen, was dazu führt Es muss immer in replaceThing vorhanden sein. Im Ausführungskontext der Funktion wird es nicht freigegeben. Dies ist ein typischer Speicherverlustfall, der durch Schließungen verursacht wird. Zusammenfassung: Zu den häufigen Speicherverlusten gehören die folgenden Situationen :🎜

• Globale Variablen
• Abschluss
• Timer
• Ereignisüberwachung
• Cache

In den oben genannten Situationen müssen Sie daher sorgfältig abwägen, ob das Objekt im Speicher automatisch recycelt wird oder nicht. Wenn ja, ist eine manuelle Recycling erforderlich B. das manuelle Festlegen des Objekts auf null, das Entfernen von Timern, das Aufheben der Bindung von Ereignis-Listenern usw.

Zusammenfassung

In diesem Artikel wurde bisher eine detaillierte Einführung in das gesamte Leistungsüberwachungssystem von Node.js gegeben.

Zunächst werden die durch Leistungsüberwachung gelösten Probleme, ihre Komponenten und ein Vergleich der Vor- und Nachteile gängiger Lösungen vorgestellt.

Dann werden die beiden wichtigsten Leistungsindikatoren und Snapshot-Tools im Detail vorgestellt.

• Die Leistungsindikatoren konzentrieren sich hauptsächlich auf die GC-Strategie und den GC-Optimierungsplan von v8 vorgestellt.
• Snapshot-Tools umfassen hauptsächlich Heap-Snapshots, CPU-Snapshots und Coredump bei Abstürzen.

Abschließend wird ein einfacher Speicherverlustfall aus Beobachtung, Analyse und Fehlerbehebung reproduziert und häufige Speicherverlustsituationen und -lösungen zusammengefasst.

Ich hoffe, dieser Artikel kann jedem helfen, das gesamte Leistungsüberwachungssystem von Node.js zu verstehen.

Weitere Informationen zu Knoten finden Sie unter: nodejs-Tutorial!

Das obige ist der detaillierte Inhalt vonWarum brauchen Sie eine Leistungsüberwachung? Lassen Sie uns über die Leistungsüberwachung von Node.j sprechen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!