Pourquoi avez-vous besoin d’un suivi des performances ? Parlons de la surveillance des performances de Node.js

Pourquoi la surveillance des performances est nécessaire

Node, en tant que moteur d'exécution pour Javascript côté serveur, enrichit considérablement les scénarios d'application de Javascript.

Cependant, le runtime Node.js lui-même est une boîte noire. Nous ne pouvons pas percevoir l'état du runtime et il est difficile de reproduire les problèmes en ligne.

Par conséquent, la surveillance des performances est la pierre angulaire du « fonctionnement normal » des applications Node.js. Non seulement divers indicateurs d’exécution peuvent être surveillés à tout moment, mais cela peut également aider à résoudre des problèmes de scénarios anormaux.

des composants

peut être divisée en deux parties :

• collecte et affichage des indicateurs de performances

  • . Données au niveau du processus : CPU, mémoire, tas, GC et autres
  • données au niveau du système : occupation du disque, charge d'E/S, état de la connexion TCP/UDP, etc.
  • Données de la couche application :

• capture et analyse des données de performances

  telles que QPS, HTTP lent, journaux de liaison de traitement métier, etc.
  • Heapsnapshot : instantané de la mémoire tas
  • Cpuprofile : instantané du processeur
  • Coredump :

comparaison des solutions d'instantanés de crash d'application

Dans l'image ci-dessus, vous pouvez voir les avantages et les inconvénients des trois solutions actuelles de surveillance des performances Node.js. Voici une brève introduction à la composition de ces trois solutions :

• Prometheus

  • prom-client est l'implémentation nodejs de prometheus. est utilisé pour collecter des indicateurs de performance.
  • Grafana est une plate-forme de visualisation utilisée pour afficher divers graphiques de données. L'accès à prometheus
  • ne prend en charge que la collecte et l'affichage d'indicateurs de performance. D'autres outils d'instantanés sont nécessaires pour résoudre les problèmes afin de former un

• AliNode en boucle fermée.

  • Alinode est un environnement d'exécution étendu compatible avec Nodejs officiel, fournissant quelques fonctions supplémentaires :

    • surveillance de l'état de la mémoire d'exécution de la v8
    • surveillance de l'état d'exécution de libuv
    • Fonctions de diagnostic des pannes en ligne : instantané du tas, profil du processeur, trace GC, etc.

  • agenthub est un processus résident utilisé pour collecter des indicateurs de performance et signalez-les.

    • Agentx intégré + Les outils pratiques de commdx

  • forment une boucle fermée à partir de la surveillance, de l'affichage, de l'instantané et de l'analyse. L'accès est pratique et simple, mais il existe toujours des risques lors de l'extension du runtime d'

• Easy-Monitor

  • xprofiler
.
• • Échantillonnage de l'état d'exécution en temps réel et journaux de performances de sortie (c'est-à-dire récupération des données de performances)
  • xtransit est responsable de la collecte et de la transmission des journaux de performances.
  • La plus grande différence par rapport à AliNode est l'utilisation Node.js Addon pour implémenter l'

indicateur de performance

CPU.

Les données de consommation de temps CPU du processus actuel peuvent être obtenues via process.cpuUsage() L'unité de la valeur de retour est la microseconde

• utilisateur : le temps CPU consommé par le processus lui-même lorsque le processus est exécuté.
• Système : le temps CPU consommé par le processus. système lorsque le processus est exécuté

Mémoire

Les données d'allocation de mémoire du processus actuel peuvent être obtenues via process.memoryUsage() . L'unité de la valeur de retour est l'octet

• rss : mémoire résidente, la taille totale de la mémoire allouée par le processus du nœud
• heapTotal : la taille de la mémoire du tas demandée par v8.
• heapUsed : le tas utilisé par la v8 Memory
• sizeexternal : La taille mémoire occupée par le C++ géré par la v8
• arrayBuffers : La taille mémoire allouée à ArrayBuffer

Comme le montre la figure ci-dessus, rss comprend le segment de code ( Code Segment ), la mémoire de pile ( Stack ) et la mémoire de tas ( Heap

• Code Segment : stocke les segments de code
Stack : stocke les variables locales et
• les
• appels de fonction de gestion.
• stocke les objets, les fermetures ou tous les autres

tas

peuvent obtenir des données d'analyse de la mémoire du tas v8 et de l'espace du tas via v8.getHeapStatistics() et v8.getHeapSpaceStatistics() La figure suivante montre la distribution de la composition de la mémoire du tas de la v8 :

L'espace mémoire du tas est d'abord divisé en espaces, et l'espace est divisé en pages. La mémoire est paginée selon un alignement de 1 Mo.

• Nouvel espace : Espace de nouvelle génération, utilisé pour stocker certaines données d'objets avec un cycle de vie relativement court, divisé en deux espaces (le type d'espace est semi space ) : from space to space

  • Conditions de promotion : survivre toujours après deux GC dans Nouvel espace

• Ancien Espace : l'espace d'ancienne génération, utilisé pour stocker les objets promus par New Space

• Code Space : stocke le code exécutable compilé par v8 JIT.

• Map Space : stocke l'objet pointeur de la classe cachée pointée par Object. v8 selon le moteur d'exécution. La structure de présentation des objets est utilisée pour accéder rapidement aux membres des objets.

• Grand espace d'objet : utilisé pour stocker les objets de plus de 1 Mo qui ne peuvent pas être alloués aux pages.

L'algorithme de récupération de place de

GC

• Majeur

• GC : utilise Mark-Sweep-Compact . GC mineur pour le recyclage d'objets dans l'ancienne génération
• : L'algorithme Scavenge est utilisé pour recycler les objets dans la nouvelle génération

Scavenge.

Prémisse : New space est divisé en deux espaces d'objets : from et to

Synchronisation du déclenchement : lorsque New space est plein.

Étapes :

• dans from space , effectuez une traversée en largeur

• et constatez que l'objet survivant (accessible)

  • a survécu une fois (. expérimenté un Scavange), promu à Old space et à
  • d'autres copies vers to space

• Lorsque la copie se termine, il ne reste que les objets survivants dans to space , from space est vidé,

• l'échange from space et to space est lancé, et le prochain cycle Scavenge commence.

est adapté à un recyclage fréquent et à une mémoire insuffisante. Pour les objets volumineux, la stratégie espace-temps typique a l'inconvénient de gaspiller deux fois plus d'espace que

Mark-Sweep-Compact.

Trois étapes : marquage, dégagement et organisation

. Chronométrage du déclenchement : lorsque Old space est plein.

Étapes :

• Marquage (méthode de marquage tricolore)

  Blanc :
  • représente les
  • objets non recyclables, et toutes les références générées. ont été scannés.
  • Gris : représente les objets non recyclables, et les références générées par ceux-ci n'ont pas encore été analysées.
  • Mettez les objets directement référencés par l'objet racine V8 dans une marking queue (pile explicite), et marquez ces objets en gris.
  • Commencez la profondeur à partir de ces objets. Donnez la priorité au parcours. Chaque fois qu'un objet est accédé, pop l'objet de marking queue et marquez-le en noir.
  • Marquez ensuite tous les objets blancs référencés par l'objet en gris et push vers marking queue
  • . tous les objets de la pile sont sautés. Jusqu'à ce qu'ils soient déposés, il n'y a que deux types d'objets dans l'ancienne génération : noirs (non recyclables) et blancs (peuvent être recyclés).
  • PS : Lorsqu'un objet est trop gros et ne peut pas être
  recyclé.
  • poussé vers la pile avec un espace limité, la v8 gardera l'objet en gris et l'ignorera, marquera la pile entière comme débordée (débordée), attendra que la pile soit effacée et traversera à nouveau la marque, ce qui nécessitera une analyse supplémentaire. du tas.

• Un balayage

  • pour effacer les objets blancs
  • entraînera une discontinuité de l'espace mémoire

• .

  • Un balayage compact entraînera une discontinuité de l'espace mémoire. Il est utile que de nouveaux objets entrent dans le GC
  • et déplacent les objets noirs (de survie) vers un seul. fin de Old space , de sorte que l'espace libéré soit continu et complet.
  • Bien que cela puisse résoudre le problème de fragmentation de la mémoire, cela augmentera le temps de pause (vitesse d'exécution lente)
  • et il n'y aura pas assez d'espace pour les nouveaux étudiants. utilisé uniquement lors de l'allocation d'objets promus

Stop-The-World

Lorsque la v8 effectue initialement un garbage collection, elle doit arrêter le programme, analyser l'intégralité du tas et récupérer la mémoire avant de réexécuter le programme. Ce comportement est appelé pause complète ( Stop-The-World ).

Bien que les objets actifs de la nouvelle génération soient petits et fréquemment recyclés, un arrêt complet a peu d'impact. Cependant, les objets survivants de l'ancienne génération sont nombreux et volumineux. et les pauses causées par le marquage, le nettoyage, le tri, etc. Ce sera plus grave.

Stratégie d'optimisation

• recyclage incrémental (Incremental Marking) : Dans la phase de marquage, lorsque le tas atteint une certaine taille, le GC incrémentiel démarre après chaque allocation d'une certaine quantité de mémoire, le programme en cours d'exécution est mis en pause et le marquage est effectué pendant quelques millisecondes. à des dizaines de millisecondes, puis reprenez le programme.

Ce concept ressemble en fait un peu à l'architecture Fibre du framework React. Ce n'est que pendant le temps libre du navigateur qu'il parcourra l'arbre Fibre pour effectuer les tâches correspondantes, sinon l'exécution sera retardée, affectant le moins possible les tâches du thread principal. , en évitant les retards des applications et en améliorant les performances des applications.

• Balayage simultané : laissez d'autres threads effectuer le balayage en même temps sans vous soucier d'un conflit avec le thread principal du programme en cours d'exécution.
• Balayage parallèle : laissez plusieurs threads de balayage fonctionner en même temps, améliorez le débit du balayage et raccourcissez l'ensemble du cycle GC.

ajustement de l'espace.

Parce que la v8 a une limite par défaut sur l'espace des nouvelles et anciennes générations.

• New space par défaut : 32 M pour les systèmes 64 bits et 16 M pour les systèmes 32 bits.
• Old space par défaut : 1400 M pour les systèmes 64 bits et. 700M pour les systèmes 32 bits.

Par conséquent, node Deux paramètres sont fournis pour ajuster la limite d'espace supérieure des nouvelles et anciennes générations

• --max-semi-space-size : Définir la valeur maximale de l' New Space Space
• --max-old-space-size : Définit la valeur maximale de Old Space space

View Le

node de journal GC propose également trois façons d'afficher les journaux GC :

• --trace_gc : Une ligne de journal décrit brièvement l'heure, le type, les changements de taille de tas et les causes de chaque GC
• --trace_gc_verbose : affiche chaque tas V8 après chaque GC État détaillé de l'espace
• --trace_gc_nvp : informations détaillées sur la paire clé-valeur de chaque GC, y compris le type de GC, le temps de pause, les modifications de mémoire, etc.

Étant donné que le journal GC est relativement primitif et nécessite

outil d'instantané

d'analyseur de journaux

Heapsnapshot

prend un instantané de la mémoire tas d'un programme en cours d'exécution et peut être utilisé pour analyser la consommation de mémoire et modifier

les méthodes de génération

des fichiers Heapsnapshot .heapsnapshot être généré des manières suivantes :

• en utilisant heapdump

• Utilisation du profil de tas de la v8

• Utilisez l'API

  • v8.getHeapSnapshot()

  fournie par le module v8 intégré de nodejs

  

  • v8.writeHeapSnapshot(fileName)

  

• Utilisation de v8-profiler-next

la méthode d'analyse

.heapsnapshot être téléchargé en mémoire sur la barre d'outils des outils de développement Chrome, et les résultats seront affichés comme indiqué ci-dessous :

La vue par défaut est Summary . Ici, nous devons faire attention aux deux colonnes les plus à droite : Shallow Size et Retained Size Size

• Retained Size
• Shallow Size la taille de l'objet lui-même alloué dans la mémoire tas v8.
• Shallow Size de tous les objets référencés de l'objet.

Lorsqu'il s'avère que Retained Size est particulièrement grande, il peut y avoir une fuite de mémoire à l'intérieur de l'objet. Vous pouvez développer davantage pour localiser le problème

Comparison Analysez les instantanés de tas de deux périodes différentes. La colonne Delta peut être utilisée pour filtrer les objets présentant les changements de mémoire les plus importants.

Cpuprofile

effectue un échantillonnage instantané du CPU exécutant le programme, qui peut être utilisé pour analyser le temps CPU et la proportion.

Il existe plusieurs façons de générer un fichier .cpuprofile :

v8

• -profiler (un outil officiellement fourni par node, mais il ne peut plus le faire)

• prend en charge la version du nœud v10 ou supérieur) et n'est plus maintenu)
• v8-profiler-next (version de maintenance chinoise, prend en charge le dernier nœud v18, sous maintenance continue)

Il s'agit d'une collection d'échantillons de profil de processeur de 5 minutes

Le fichier .cpuprofile généré Javascript Profiler

la méthode d'analyse

La vue par défaut est la vue Heavy . Ici nous voyons deux colonnes : Self Time et Total Time Time

: représente le temps d'exécution de cette fonction elle-même (hors autres appels).
• Total Time : représente le temps d'exécution de cette fonction (y compris les autres)
• Self Time
• fonctions d'appel). Lorsqu'il s'avère que le temps total et le temps personnel diffèrent considérablement, la fonction

Total Time Self Time un calcul gourmand en CPU qui prend beaucoup de temps. Vous pouvez également effectuer un dépannage supplémentaire.

Lorsque

l'application se bloque et se termine de manière inattendue. le système l'enregistrera automatiquement. Le processus plante les informations d'allocation de mémoire, le compteur de programme et le pointeur de pile et d'autres informations clés à ce moment-là pour générer

des méthodes de génération

. Trois méthodes pour générer des fichiers .core :

• ulimit -c unlimited ouvre la limite du noyau.
• node --abort-on-uncaught-exception L'ajout de ce paramètre au démarrage du noeud peut générer un fichier core lorsqu'une exception non capturée se produit dans l'application
• gcore <pid> Générer manuellement

une méthode d'analyse

.Après avoir obtenu le fichier .core , analysez. le diagnostic peut être réalisé grâce à des outils tels que mdb, gdb, lldb, etc. La cause réelle du crash du processus

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

observation

d'analyse de cas

Lors de la surveillance, on peut observer que la mémoire du tas continue d'augmenter, des instantanés du tas sont donc nécessaires pour le dépannage

et l'analyse.

Grâce au heapsnapshot nous pouvons analyser et découvrir qu'il existe un objet newThing qui a toujours conservé une mémoire relativement grande

.

d'un résumé

unused theThing newThing . Les cas replaceThing causés par des fermetures.

Les fuites de mémoire courantes incluent les situations suivantes :

• variables globales,
• fermetures,
• minuteries,
• caches
• d'écoute d'événements
.

Par conséquent, dans les situations ci-dessus, vous devez soigneusement déterminer si l'objet en mémoire sera automatiquement recyclé. ne soit pas automatiquement recyclé, vous devez effectuer un recyclage manuel, comme la définition manuelle des objets sur null , la suppression des minuteries, la dissociation des écouteurs d'événements, etc.

conclut

cet article. Cet article a donné une introduction détaillée à l'ensemble du système de surveillance des performances de Node.js.

Premièrement, il présente les problèmes résolus par la surveillance des performances, ses composants et une comparaison des avantages et des inconvénients des solutions traditionnelles.

Ensuite, les deux principales parties des indicateurs de performances et des outils d'instantanés sont présentées en détail.

• Les indicateurs de performances se concentrent principalement sur les indicateurs CPU, mémoire, espace de mémoire et GC. En même temps, la stratégie GC et le plan d'optimisation GC de la v8 sont présentés.
Les outils
• d'
• instantané incluent principalement l'instantané de tas, l'instantané du processeur et le Coredump en cas de crash.

Enfin, un cas simple de fuite de mémoire est reproduit à partir de l'observation, de l'analyse et du dépannage, et les situations et solutions courantes de fuite de mémoire sont résumées.

J'espère que cet article pourra aider tout le monde à comprendre l'ensemble du système de surveillance des performances de Node.js.