Node.js fournit des outils puissants pour mesurer et optimiser les performances de vos applications. L'un de ces outils est la Performance API, qui permet aux développeurs de capturer des horodatages haute résolution et diverses mesures de performance. Ce guide vous présentera les principaux composants de la Node.js Performance API et comment les utiliser efficacement.
Pourquoi la performance est importante dans Node.js
Node.js brille par son architecture événementielle et asynchrone, parfaitement adaptée aux tâches liées aux E/S. Cependant, même dans cet environnement non bloquant, la performance reste primordiale. Les applications lentes conduisent à la frustration des utilisateurs et entravent l'évolutivité. L'identification des goulots d'étranglement et l'optimisation du code deviennent essentielles pour une expérience utilisateur transparente.
Intéressé par l'augmentation du temps de réponse de votre API ? L'article suivant propose un guide étape par étape sur la façon d'augmenter le temps de réponse de votre API.
Pourquoi utiliser la Node.js Performance API ?
- Identifier les goulots d'étranglement de performance : Les goulots d'étranglement de performance peuvent dégrader considérablement l'expérience utilisateur. En utilisant la Performance API, les développeurs peuvent identifier les moments exacts où des retards se produisent, que ce soit dans l'exécution de fonctions, le chargement de ressources ou la gestion des requêtes HTTP. Cette précision permet des optimisations ciblées.
- Optimiser l'utilisation des ressources : La surveillance des performances permet de comprendre comment les ressources telles que le processeur et la mémoire sont utilisées. En identifiant une utilisation inefficace des ressources, les développeurs peuvent optimiser leur code pour qu'il soit plus efficace, réduisant ainsi les coûts et améliorant l'évolutivité.
- Améliorer l'expérience utilisateur : Les applications qui répondent rapidement offrent une meilleure expérience utilisateur. La Performance API aide à mesurer les indicateurs clés tels que le Time to First Byte (TTFB) et le First Contentful Paint (FCP), ce qui permet aux développeurs d'apporter des améliorations qui conduisent à des temps de chargement plus rapides et à des interactions plus fluides.
- Améliorer la stabilité de l'application : La surveillance continue des performances permet de détecter les anomalies et les problèmes potentiels avant qu'ils ne deviennent critiques. Cette approche proactive garantit une disponibilité et une fiabilité accrues de l'application.
Introduction à la Node.js Performance API
La Performance API, accessible via le module perf_hooks, fournit aux développeurs Node.js une boîte à outils complète pour mesurer et analyser les performances des applications. Elle offre un avantage significatif par rapport aux méthodes traditionnelles comme Date.now(), en fournissant une synchronisation haute résolution et une approche plus structurée de l'évaluation des performances. Dans la méthode Date.now(), vous verrez quelque chose comme ;
const startTime = Date.now();
// call a function to perform a task()
console.log(`Task duration: ${Date.now() - startTime} milliseconds`);
La fonction Date.now() fonctionne bien, mais encore une fois, bien que cela semble simple, cette méthode peut être peu fiable car les changements d'horloge système peuvent fausser les mesures.
C'est là que la Node.js Performance API entre en scène. Nous voulons être en mesure de mesurer pleinement l'utilisation du temps de notre application et ne pas être ennuyés par des choses comme l'horloge système, n'est-ce pas ?
La Node.js Performance API est construite autour de plusieurs méthodes et classes de base fournies par le module perf_hooks. Ceux-ci incluent :
Chacun de ces outils sert un objectif distinct dans la capture et l'analyse des mesures de performance.
Utilisation de performance.now()
La méthode performance.now() renvoie un horodatage haute résolution en millisecondes. Ceci est utile pour mesurer les intervalles au sein de votre application avec une plus grande précision que Date.now().
Pour obtenir la durée d'une tâche, ajoutez la méthode performance.now() au début et à la fin de l'opération que vous souhaitez mesurer comme suit ;
const { performance } = require('node:perf_hooks');
const start = performance.now();
// Perform some operations
const end = performance.now();
console.log(`Time taken: ${end - start} ms`);
Tout d'abord, nous importons la performance des modules node, puis nous créons des constantes de début et de fin et leur attribuons les méthodes performance.now pour obtenir l'heure exacte de l'opération.
La sortie du code ci-dessus devrait ressembler à ce qui suit ;
Time taken: 1253.**** ms.Utilisation de performance.mark()
La méthode performance.mark() dans Node.js vous permet de créer des horodatages nommés (ou marques) à des points spécifiques de votre code. Ces marques vous aident à mesurer le temps nécessaire entre les différentes parties de votre application, vous donnant ainsi un aperçu des goulots d'étranglement de performance.
const { performance } = require('node:perf_hooks');
performance.mark('A');
// Some operations
performance.mark('B');
Dans cet exemple, performance.mark('A') et performance.mark('B') créent deux marques étiquetées 'A' et 'B', respectivement.
Les marques peuvent également inclure des détails supplémentaires, ce qui peut être utile pour le débogage ou une analyse plus approfondie.performance.mark('A', { detail: 'Start of operation' }); performance.mark('B', { detail: 'End of operation' });
Ici, la propriété detail fournit des informations supplémentaires sur ce que chaque marque représente.
Une fois que vous avez créé des marques, vous pouvez mesurer la durée entre elles à l'aide de performance.measure().
Utilisation de performance.measure()
performance.measure() est une fonction de la Performance API de Node.js qui calcule spécifiquement la durée entre deux points marqués dans la chronologie d'exécution de votre application. Elle crée essentiellement une entrée de mesure et stocke le temps écoulé pour une récupération et une analyse ultérieures.
N'oubliez pas que dans la section performance.mark(), nous avons créé deux marques : A & B. Dans cette section, nous allons les tester et voir comment performance.mark() fonctionne avec performance.measure().
performance.measure('A to B', 'A', 'B');
const measures = performance.getEntriesByType('measure');
measures.forEach(measure => {
console.log(`${measure.name}: ${measure.duration}ms`);
});
Cela créera une mesure nommée 'A to B', qui calcule le temps écoulé entre les marques 'A' et 'B'.
Lorsque vous exécutez le code ci-dessus, la sortie affichera la durée entre les deux marques 'A' et 'B'. Voici un exemple de ce que la console pourrait imprimer :
A to B: 12.345ms
Cette sortie indique que les opérations entre les marques 'A' et 'B' ont pris environ 12,345 millisecondes pour se terminer.
Utilisation de PerformanceObserver
L'interface PerformanceObserver dans Node.js permet aux développeurs d'observer et de gérer de manière asynchrone les entrées de performance telles que les marques, les mesures et les entrées de synchronisation des ressources. Elle est particulièrement utile pour surveiller et réagir aux données de performance au fur et à mesure de leur collecte, ce qui en fait un outil essentiel pour l'analyse et l'optimisation des performances en temps réel.
Pour utiliser PerformanceObserver, vous devez en créer une instance et définir une fonction de rappel qui gérera les entrées de performance. Voici une configuration de base :
const { PerformanceObserver, performance } = require('node:perf_hooks');
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
console.log(entry);
});
});
observer.observe({ entryTypes: ['mark', 'measure'] });
Dans cet exemple :
- Importation de
PerformanceObserveretperformance: Les objetsPerformanceObserveretperformancesont importés du moduleperf_hooks. - Création d'un observateur : Une instance de
PerformanceObserverest créée avec une fonction de rappel. Cette fonction est appelée chaque fois que de nouvelles entrées de performance sont enregistrées. - Observation des types d'entrées : La méthode
observer.observeest appelée avec un objet spécifiant les types d'entrées à observer (marketmeasuredans ce cas).
Cas d'utilisation pratiques pour PerformanceObserver
1. Surveillance des performances en temps réel :
PerformanceObservervous permet de surveiller en permanence les performances de l'application, en fournissant un retour d'information immédiat sur les problèmes de performances. Ceci est particulièrement utile dans les environnements de production où les données de performance en temps réel sont essentielles.
2. Analyse du chargement des ressources :
- En observant les entrées de synchronisation des ressources, les développeurs peuvent analyser la façon dont diverses ressources (telles que les scripts, les feuilles de style et les images) sont chargées, ce qui permet d'optimiser les temps de chargement.
3. Débogage et profilage :
- Pendant le développement,
PerformanceObserverpeut être utilisé pour profiler des parties spécifiques du code, en identifiant les fonctions lentes et les goulots d'étranglement potentiels.
4. Mesures de performance personnalisées :
- Les développeurs peuvent créer des mesures de performance personnalisées en marquant et en mesurant les points importants de l'application, ce qui permet une analyse des performances plus granulaire adaptée aux besoins spécifiques de l'application.
Tests d'applications dans Node.js
Jusqu'à présent, nous avons appris la Node.js Performance API, pourquoi elle est importante, comment elle fonctionne et en quoi elle diffère de la fonction Date.now() par défaut.
Si vous créez une application, vous voudrez vous concentrer sur la création de votre application et laisser les tests à d'autres services. Eh bien, grâce à Apidog, vous pouvez tester vos API et vos applications.
Apidog est un outil puissant spécialement conçu pour les tests d'API, y compris les tests de performance. Il offre des solutions complètes pour la création, la gestion et le test des API. Apidog vous permet de simuler les comportements des API, de définir des cas de test et de générer des rapports détaillés. Grâce à son interface intuitive, vous pouvez facilement configurer des tests de performance, analyser les temps de réponse et identifier les goulots d'étranglement de performance.
Conclusion
La Node.js Performance API, y compris des outils tels que performance.mark(), performance.measure() et PerformanceObserver, fournit aux développeurs de puissantes capacités pour surveiller et optimiser les performances des applications. En tirant parti de ces outils, vous pouvez obtenir des informations précises sur les caractéristiques de performance de vos applications Node.js, identifier les goulots d'étranglement et mettre en œuvre des optimisations ciblées pour améliorer l'efficacité et l'expérience utilisateur.
Au-delà de la Performance API, l'utilisation des meilleures pratiques d'API/d'application, ainsi que des tests de charge et une surveillance robustes peuvent considérablement améliorer les performances globales de vos applications. Ces efforts combinés garantissent que vos applications Node.js fonctionnent sans problème, s'adaptent efficacement et offrent une expérience utilisateur supérieure, maintenant ainsi un avantage concurrentiel sur le marché.
