Aller au contenu
Encyclopédie informatique Édition 2026

L'observabilité : journaux, métriques et traces

Une application moderne ne tient plus sur une seule machine : elle est faite de dizaines de petits services qui s’appellent les uns les autres, souvent déplacés, copiés ou arrêtés automatiquement par la plateforme qui les héberge. Quand un client se plaint que « c’est lent », où chercher ? L’observabilité est l’art de répondre à cette question sans deviner. Elle repose sur trois sortes de signaux que le système émet lui-même : les journaux (le récit des événements), les métriques (des mesures chiffrées) et les traces (le voyage d’une requête à travers les services). Cet article explique ce que chacun apporte et coûte, comment on les relie, comment on fixe des objectifs de qualité mesurables, comment on déclenche des alertes qui servent à quelque chose, et comment on en tire des leçons après un incident. Il traite aussi des risques de sécurité propres à ces données, car un journal bien tenu est une arme de défense, et mal tenu une fuite.

Rubrique
Cloud et virtualisation
Niveau
Intermédiaire
Lecture
30 min (essentiel)
33 min (complet)
Révision
4 novembre 2026
Niveau de lecture :

En bref

  • La supervision répond à « est-ce que ça marche ? » avec des seuils prévus d’avance ; l’observabilité permet aussi de répondre à des questions qu’on n’avait pas prévues, parce que le système émet assez de signaux.
  • Trois signaux se complètent : les journaux disent ce qui s’est passé, les métriques disent si cela va mal, les traces disent où chercher dans une chaîne de services.
  • On fixe des objectifs de service (SLO) sur ce que vivent les utilisateurs, on mesure leur respect (SLI) et on alerte sur les symptômes, pas sur chaque détail technique.
  • OpenTelemetry est la norme ouverte pour produire et transporter ces signaux, ce qui évite d’être enfermé chez un fournisseur.
  • Les signaux contiennent des secrets et des données personnelles en puissance : on décide quoi collecter, qui peut lire, combien de temps on garde.

Prérequis conseillés : Le cloud computing

1De la supervision à l’observabilité

Dans les années 2000, surveiller un système informatique voulait dire regarder des voyants. La supervision des réseaux classique repose sur des sondes qui interrogent régulièrement chaque équipement : la machine répond-elle ? Le disque est-il plein à plus de 90 % ? La charge du processeur est-elle anormale ? Ces vérifications fonctionnent très bien tant que le système est stable, que l’on sait à l’avance ce qui peut tomber en panne et que chaque machine a un nom et une place connus. On appelle cela la supervision (en anglais monitoring) : on choisit des mesures et des seuils à l’avance et on prévient quand un seuil est franchi.

Le monde de l’informatique en nuage a bousculé ces habitudes. Une application est maintenant découpée en de nombreux microservices (petits programmes qui se parlent par le réseau, voir aussi les interfaces de programmation), chacun exécuté dans des conteneurs qui naissent et meurent en quelques minutes, parfois sur des machines que personne ne gère directement. Quand un utilisateur dit « ma commande n’a pas marché », la panne peut venir d’un des quarante services, d’un réseau entre deux d’entre eux, d’une base de données saturée, d’un changement de configuration fait la veille ou de la combinaison de plusieurs choses mineures. Aucun voyant prévu à l’avance ne la montre.

L’observabilité désigne la capacité de comprendre l’état interne d’un système à partir de ce qu’il émet vers l’extérieur. Le mot vient de l’automatique, une branche de l’ingénierie qui étudie le contrôle de machines : un système y est dit « observable » si l’on peut reconstituer son état interne en observant seulement ses sorties. Transposé à l’informatique, il veut dire que le système doit être conçu pour émettre assez de signaux pour qu’on puisse l’interroger, y compris pour des questions qu’on n’avait pas prévues. On distingue souvent les « inconnues connues » (une panne qu’on sait possible, que la supervision guette) des « inconnues inconnues » (une panne dont personne n’avait imaginé la forme, que seule la richesse des signaux permet de comprendre).

1.1Les trois signaux

On range les signaux en trois familles, souvent appelées les « trois piliers » (la figure 1 les résume). Chacune répond à une question différente :

  • les journaux (logs) racontent les événements un par un : « à 14 h 03 min 12 s, l’utilisateur 42 a demandé la page de paiement ; la banque a répondu par une erreur » ;
  • les métriques (metrics) mesurent des quantités à intervalles réguliers : nombre de requêtes par seconde, part d’erreurs, délai de réponse, mémoire utilisée ;
  • les traces (traces) suivent une seule requête de bout en bout, à travers tous les services, avec le temps passé à chaque étape.
TROIS SIGNAUX POUR COMPRENDRE UN SYSTÈME Journaux (logs) le récit des événements quoi, quand, avec quel message Métriques des mesures chiffrées combien : débit, erreurs, délai Traces le voyage d’une requête où : quel service, combien de temps Les journaux disent ce qui s’est passé, les métriques disent si ça va mal, les traces disent où chercher.
Figure 1. Trois signaux complémentaires : le récit (journaux), la mesure (métriques) et le parcours (traces).

Aucun signal ne suffit seul. Une métrique montre que le taux d’erreurs a grimpé à 8 %, mais pas pourquoi. Un journal contient la cause, mais noyé parmi des millions de lignes. Une trace montre que l’étape lente est l’appel au service de paiement, mais pas le message d’erreur précis. L’observabilité vient de la combinaison : la métrique alerte, la trace localise, le journal explique.

1.2Ce que l’observabilité n’est pas

  • Ce n’est pas un produit à acheter. C’est une propriété du système, qu’on obtient en l’instrumentant (en y ajoutant du code qui émet des signaux) et en organisant leur exploitation. Des outils aident, mais un outil sans bons signaux ne montre rien d’utile.
  • Ce n’est pas « tout enregistrer ». Garder tous les signaux de tous les services coûte très cher en stockage, en réseau et en temps de recherche. Un bon dispositif choisit.
  • Ce n’est pas réservé aux grandes entreprises. Même un petit site gagne à avoir des journaux lisibles, quelques métriques et une alerte qui prévient quand il ne répond plus.

1.3Le plan de l’article

La partie 2 traite des journaux, la partie 3 des métriques, la partie 4 des traces (figure 2). La partie 5 explique comment les relier et présente la norme OpenTelemetry. La partie 6 aborde les objectifs de service, la partie 7 les alertes et la boucle d’amélioration (figure 3). Les parties 8 à 10 portent sur l’organisation d’un dispositif, les coûts et le bilan de quinze ans d’évolution. La partie 11 propose sept exercices.

Pour s’exercer

Exercice 1 : quel signal pour quelle question ?

Pour chaque question, dites s’il vaut mieux regarder un journal, une métrique ou une trace : (a) « Le site est-il plus lent qu’hier ? » ; (b) « Pourquoi la commande 7781 a-t-elle échoué ? » ; (c) « Quel service ralentit les paiements ? » ; (d) « Combien d’erreurs par minute depuis 14 h ? »

Voir la réponse

(a) Une métrique (la durée des requêtes, comparée à hier). (b) Un journal : le message d’erreur et le contexte de cette commande, retrouvés par l’identifiant de corrélation. (c) Une trace : elle montre quelle étape de la chaîne prend du temps. (d) Une métrique : un compteur d’erreurs dont on regarde la vitesse.

2Les journaux : le récit des événements

Un journal (en anglais log) est une suite de lignes, chacune décrivant un événement avec la date et l’heure où il s’est produit. C’est le signal le plus ancien et le plus familier : tous les programmes en écrivent un, depuis les systèmes d’exploitation (voir les processus) jusqu’aux serveurs web. Il répond à la question la plus simple et la plus précieuse : que s’est-il passé exactement ?

Un journal utile contient au minimum : un horodatage précis (date, heure, fuseau), un niveau de gravité, le nom du programme qui parle, un message et du contexte (identifiant de la requête, de l’utilisateur, de la machine).

2.1Les niveaux de gravité

La plupart des bibliothèques de journalisation proposent une échelle de niveaux, du plus bavard au plus grave. Les noms varient un peu, mais on retrouve presque toujours :

  • DEBUG (mise au point) : détails utiles aux développeurs, normalement désactivés en production car ils sont très nombreux ;
  • INFO : événements normaux notables (démarrage, connexion d’un utilisateur, fin d’un traitement) ;
  • WARNING (avertissement) : quelque chose d’anormal mais récupérable (une nouvelle tentative réussie, un disque rempli aux trois quarts) ;
  • ERROR (erreur) : une opération a échoué ;
  • CRITICAL ou FATAL : une défaillance qui met en cause le programme entier.

Choisir le bon niveau est un vrai travail. Un programme qui écrit « erreur » à chaque fois qu’un visiteur tape un mot de passe faux noie les vraies erreurs ; un programme qui n’écrit rien avant de planter ne laisse aucun indice. Règle pratique : une erreur de niveau ERROR doit être quelque chose que quelqu’un devra un jour regarder ou corriger.

2.2Journaux de texte libre et journaux structurés

La forme classique est une ligne de texte libre : 2026-11-04 14:03:12 ERROR paiement : la banque n'a pas répondu (commande 7781). Elle se lit bien, mais se prête mal aux recherches : pour retrouver toutes les erreurs de la commande 7781, il faut deviner la forme exacte de la phrase. La pratique moderne est le journal structuré : chaque événement est un petit objet composé de champs nommés, le plus souvent au format JSON (voir XML et JSON) :

{"heure":"2026-11-04T14:03:12Z","niveau":"ERROR","service":"paiement",
 "message":"la banque n'a pas répondu","commande":7781,"duree_ms":5000}

Le message reste lisible, mais les champs peuvent être filtrés, comptés et triés par un outil : « tous les événements de niveau ERROR du service paiement dont la durée dépasse 3 000 millisecondes pour la commande 7781 ». C’est la même idée que celle d’une base de données (voir les bases de données) : on range de l’information dans des champs plutôt que dans un texte. La structure demande de la discipline : des noms de champs identiques d’un service à l’autre (toujours commande, jamais cmd ici et order là).

2.3L’heure : un détail qui compte énormément

Reconstituer une panne revient à ordonner des événements venus de plusieurs machines. Cela suppose que leurs horloges soient d’accord. Deux précautions s’imposent. D’abord, synchroniser les horloges par un protocole de temps réseau (NTP, Network Time Protocol), faute de quoi un événement semble se produire avant sa cause. Ensuite, écrire les heures en temps universel (UTC, le temps de référence mondial, sans heure d’été ni fuseau) avec un format non ambigu, comme celui de la norme ISO 8601 (2026-11-04T14:03:12Z, où le Z signifie UTC). On convertit en heure locale seulement à l’affichage. Une équipe qui mélange heure d’été et heure d’hiver dans ses journaux perd des heures à chaque enquête.

2.4Un fil conducteur : l’identifiant de corrélation

Une même requête d’utilisateur traverse plusieurs services, chacun écrit ses propres lignes. Pour les retrouver ensemble, on attribue à chaque requête un identifiant de corrélation (une suite de caractères unique) au moment où elle entre dans le système, et chaque service le recopie dans tous ses journaux et le transmet au suivant. Une seule recherche de cet identifiant fait remonter, dans l’ordre, toute l’histoire de la requête. C’est la version artisanale de ce que font les traces (partie 4), et un excellent premier pas pour un système qui n’en a pas.

2.5Où vont les journaux ?

Un programme peut écrire ses journaux dans un fichier local, mais cette solution a des défauts dans un monde de conteneurs : le conteneur disparaît avec ses fichiers, et il faut chercher sur des dizaines de machines. La pratique recommandée est donc de centraliser : chaque programme écrit ses journaux sur sa sortie standard (l’écran virtuel du programme), un agent installé sur la machine les collecte, éventuellement les enrichit (nom du serveur, du conteneur, de la version) et les envoie à un service central qui les stocke et permet de les interroger. Plusieurs protocoles existent depuis longtemps, dont syslog (le format et le protocole historiques des journaux sous Unix et Linux, voir Linux). Des outils libres comme Loki, OpenSearch ou la pile Elastic, ou des services en ligne, jouent le rôle de stockage central.

Trois contraintes demandent des décisions explicites. La rotation : un fichier de journal grossit sans fin ; on le découpe périodiquement et on compresse ou supprime les anciens. La rétention : combien de temps garde-t-on les journaux ? Trop peu, et l’on ne peut pas enquêter sur un incident découvert tardivement ; trop, et l’on paie du stockage et on accumule des données sensibles. Le volume : un service très sollicité peut produire des centaines de gigaoctets de journaux par jour, ce qui coûte cher à stocker et à parcourir.

2.6Ce qu’il ne faut jamais journaliser

Un journal est lu par beaucoup de monde (développeurs, exploitants, prestataires) et copié dans plusieurs outils. On n’y écrit donc jamais de mots de passe, de clés d’accès, de jetons de connexion, de numéros de carte bancaire entiers, ni de contenu de messages privés. Les données personnelles (adresses, noms, adresses IP) y sont limitées au nécessaire. Une erreur fréquente est de journaliser une requête complète « pour déboguer » : elle contient alors l’en-tête d’identification de l’utilisateur. Le coin cyber détaille ce risque.