Améliorez votre surveillance Node.js avec ces métriques essentielles

En tant que développeur Node.js, assurer le bon fonctionnement de vos applications est crucial. Mais comment savoir ce qui se passe sous le capot ? C'est là que les métriques entrent en jeu. Dans cet article, nous explorerons quelques métriques clés qui vous aideront à surveiller et à optimiser vos applications Node.js comme un pro.

Pour en savoir plus, vous pouvez consulter l'article de blog complet.

1. Utilisation du processeur

? Gardez le cerveau de votre application en bonne santé.

Surveillez l'utilisation du processeur pour vous assurer que votre application ne se surmène pas.

const os = require('os');

function getCPUUsage() {
  const cpus = os.cpus();
  const totalUsage = cpus.reduce((acc, cpu) => acc + cpu.times.user + cpu.times.system, 0);
  const totalIdle = cpus.reduce((acc, cpu) => acc + cpu.times.idle, 0);
  return totalUsage / (totalUsage + totalIdle) * 100;
}

2. Utilisation de la mémoire

? Ne laissez pas votre application devenir un monopole de la mémoire.

Suivez l'utilisation de la mémoire pour éviter les fuites et optimiser les performances.

const v8 = require('v8');

function getMemoryUsage() {
  const memoryUsage = process.memoryUsage();
  const heapStats = v8.getHeapStatistics();
  return {
    rss: memoryUsage.rss,
    heapTotal: memoryUsage.heapTotal,
    heapUsed: memoryUsage.heapUsed,
    external: memoryUsage.external,
    heapSizeLimit: heapStats.heap_size_limit
  };
}

3. Décalage de la boucle d'événement

⏱️ Gardez votre application réactive.

Surveillez le décalage de la boucle d'événement pour garantir une exécution fluide des opérations asynchrones.

const lag = require('event-loop-lag');

const lagMonitor = lag(1000);

function getEventLoopLag() {
  return lagMonitor();
}

4. Taux de requêtes HTTP

? Suivez la popularité de votre application.

Surveillez le taux de requêtes HTTP entrantes pour évaluer le trafic et planifier la mise à l'échelle.

const http = require('http');

let requestCount = 0;

http.createServer((req, res) => {
  requestCount++;
  // Your server logic here
}).listen(3000);

function getRequestRate() {
  const rate = requestCount;
  requestCount = 0;
  return rate;
}

setInterval(() => {
  console.log(`Request rate: ${getRequestRate()} requests/second`);
}, 1000);

5. Pool de connexions à la base de données

?‍♂️ Gardez vos connexions à la base de données sous contrôle.

Surveillez votre pool de connexions pour garantir une utilisation efficace des ressources.

const mysql = require('mysql');

const pool = mysql.createPool({
  connectionLimit: 10,
  host: 'localhost',
  user: 'your_username',
  password: 'your_password',
  database: 'your_database'
});

function getConnectionPoolStats() {
  return {
    total: pool._allConnections.length,
    free: pool._freeConnections.length,
    queued: pool._connectionQueue.length
  };
}

6. Mesures de collecte des déchets

?️ Gardez la mémoire de votre application propre.

Surveillez le garbage collection pour optimiser la gestion de la mémoire.

javascriptCopyconst v8 = require('v8');

const gcStats = v8.getHeapStatistics();

function getGCMetrics() {
  return {
    totalHeapSize: gcStats.total_heap_size,
    usedHeapSize: gcStats.used_heap_size,
    heapSizeLimit: gcStats.heap_size_limit
  };
}

7. Poignées et demandes actives

? Suivez les opérations en cours.

Surveillez les descripteurs et les demandes actifs pour garantir une bonne gestion des ressources.

javascriptCopyfunction getActiveHandlesAndRequests() {
  return {
    activeHandles: process._getActiveHandles().length,
    activeRequests: process._getActiveRequests().length
  };
}

8. Taux d'erreur

❌ Restez au courant des problèmes.

Surveillez le taux d'erreur de votre application pour identifier et résoudre rapidement les problèmes.

javascriptCopylet errorCount = 0;

process.on('uncaughtException', (error) => {
  errorCount++;
  // Log or handle the error
});

function getErrorRate() {
  const rate = errorCount;
  errorCount = 0;
  return rate;
}

setInterval(() => {
  console.log(`Error rate: ${getErrorRate()} errors/minute`);
}, 60000);

9. Temps de réponse

⏱️ Gardez vos utilisateurs satisfaits.

Surveillez les temps de réponse pour garantir une expérience utilisateur rapide.

javascriptCopyconst responseTime = require('response-time');
const express = require('express');

const app = express();

app.use(responseTime((req, res, time) => {
  console.log(`${req.method} ${req.url} - Response time: ${time}ms`);
}));

// Your routes here

10. Dépendances des services tiers

? Ne laissez pas les services externes vous ralentir.

Surveillez les performances des services tiers dont dépend votre application.

javascriptCopyconst axios = require('axios');

async function checkExternalService(url) {
  const start = Date.now();
  try {
    await axios.get(url);
    const duration = Date.now() - start;
    console.log(`External service ${url} response time: ${duration}ms`);
  } catch (error) {
    console.error(`Error checking external service ${url}: ${error.message}`);
  }
}

// Check external services periodically
setInterval(() => {
  checkExternalService('https://api.example.com');
}, 60000);

Astuce bonus : utilisez un outil de surveillance

?️ Boostez votre surveillance ! Pensez à utiliser un outil de surveillance dédié pour automatiser la collecte de métriques et obtenir des informations plus approfondies.
Les options populaires incluent :

• Prométhée avec Grafana
• Nouvelle relique
• Datadog
• AppDynamics

Ces outils peuvent fournir des solutions de surveillance prêtes à l'emploi et de superbes tableaux de bord pour visualiser les performances de votre application Node.js.
En intégrant ces mesures et conseils supplémentaires, vous aurez une vue encore plus complète de la santé et des performances de votre application Node.js. N’oubliez pas que la clé d’une surveillance efficace ne consiste pas seulement à collecter des données, mais également à comprendre et à agir en fonction des informations qu’elles fournissent. Bon suivi !

Conclusion

En surveillant ces métriques essentielles, vous obtiendrez des informations précieuses sur les performances et la santé de votre application Node.js. N'oubliez pas que la connaissance, c'est le pouvoir, et avec ces indicateurs à portée de main, vous serez bien équipé pour optimiser votre application et assurer son bon fonctionnement.

Si vous avez besoin d'aide pour surveiller votre application, consultez https://alerty.ai pour en savoir plus sur la surveillance simple du frontend.

Bon suivi, et que vos applications Node.js fonctionnent toujours à leur meilleur ! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!