Mesurer la santé du service

Un processus Node.js peut être démarré alors que la base de données est inaccessible ou que la file de factures ne répond plus. À l’inverse, un service disponible peut approcher de ses limites : mémoire élevée, requêtes lentes ou file qui s’accumule. Vous allez distinguer ces deux situations et fournir des indicateurs exploitables par une supervision.

Vous avez déjà séparé la configuration par environnement et ajouté des journaux structurés avec un identifiant de corrélation. Ici, les journaux aident à comprendre un événement précis ; les indicateurs résument l’état et l’activité du service sur une période.

Distinguer disponibilité et état opérationnel

Un contrôle de santé répond à une question limitée : le service peut-il recevoir du trafic, et ses dépendances indispensables répondent-elles ? Le contrôle de vie vérifie plutôt que le processus fonctionne encore. Ne faites pas échouer ce dernier simplement parce qu’une dépendance temporairement indisponible provoque une erreur : un redémarrage en boucle aggraverait parfois l’incident.

Pour le service de commandes, le contrôle de disponibilité doit au minimum vérifier la base si elle est nécessaire au traitement des requêtes. Vous pouvez aussi vérifier la file lorsque l’API ne peut pas accepter de demandes de facturation sans elle. L’endpoint doit rester léger, ne pas lancer de travail coûteux et répondre rapidement avec un code HTTP distinct entre état sain et état dégradé.

Suivre activité, durée et saturation

Un compteur de requêtes indique le volume traité depuis le démarrage. Une durée moyenne aide à repérer une dégradation, mais peut masquer quelques requêtes extrêmement lentes ; en production, suivez aussi des percentiles, par exemple le 95e. Pour interpréter ces valeurs, associez-les au nombre de requêtes en erreur et à une période d’observation définie par votre système de supervision.

La saturation se lit à partir de plusieurs signaux : mémoire utilisée, délai de réponse et quantité de tâches en attente. Un nombre croissant de factures en file alors que le worker consomme régulièrement peut signaler une charge supérieure à sa capacité. Ce nombre doit être fourni par le composant de file injecté ; ne le reconstituez pas à partir des journaux.

function creerIndicateurs({ verifierBase, verifierFile, lireProfondeurFile }) {
  const debut = process.hrtime.bigint();
  const compteurs = { requetes: 0, erreurs: 0, dureeTotaleMs: 0 };

  function enregistrerRequete({ dureeMs, statut }) {
    compteurs.requetes += 1;
    compteurs.dureeTotaleMs += dureeMs;
    if (statut >= 500) compteurs.erreurs += 1;
  }

  async function lireSante() {
    const [base, file] = await Promise.all([
      verifierBase(),
      verifierFile()
    ]);
    const disponible = base && file;
    return {
      statut: disponible ? 200 : 503,
      corps: { etat: disponible ? 'disponible' : 'indisponible' }
    };
  }

  async function lireMetriques() {
    return {
      processus: {
        uptimeSecondes: Math.floor(Number(process.hrtime.bigint() - debut) / 1e9),
        memoireUtiliseeOctets: process.memoryUsage().heapUsed
      },
      requetes: {
        total: compteurs.requetes,
        erreurs5xx: compteurs.erreurs,
        dureeMoyenneMs: compteurs.requetes
          ? compteurs.dureeTotaleMs / compteurs.requetes
          : 0
      },
      file: { enAttente: await lireProfondeurFile() }
    };
  }

  return { enregistrerRequete, lireSante, lireMetriques };
}

module.exports = { creerIndicateurs };

Branchez enregistrerRequete sur le middleware de mesure, en calculant la durée avec une horloge monotone comme process.hrtime.bigint(). Dans les routes de santé et de métriques, transmettez le code HTTP retourné par lireSante() et sérialisez son corps ; lireMetriques() fournit les valeurs à exposer. Injectez des vérifications réelles de base et de file, et définissez lesquelles sont indispensables pour accepter du trafic.

Le compteur est local au processus : il repart à zéro au redémarrage et ne représente pas à lui seul l’ensemble des instances. La durée moyenne est également une mesure simplifiée, à compléter par des percentiles et une ventilation par route lorsque votre instrumentation les fournit. Le code expose la mémoire du tas JavaScript, pas toute la mémoire du processus ; comparez donc cet indicateur aux limites configurées pour le conteneur.

À retenir

• Séparez le contrôle de disponibilité du simple fait que le processus soit actif.
• Vérifiez uniquement les dépendances indispensables au service rendu.
• Suivez volume, erreurs et durées, puis complétez la moyenne par des percentiles.
• Surveillez la saturation avec des signaux concrets, notamment la mémoire et la profondeur de la file.
• Limitez les informations publiques des endpoints de santé et exposez les métriques à une supervision.

La prochaine leçon définira le contrat des tâches de facture qui circuleront dans la file.