TechniqueDécouverte6 min de lecture
L'observabilité en 10 minutes
Monitoring et observabilité, les signaux (métriques, logs, traces, profils, événements), la façon de les relier et la cardinalité, expliqués sur un seul exemple : un paiement trop lent.
Pour : ingénieurs et SRE · architectes · managers d’équipe · métiers et produitPrérequis : Aucun. Savoir ce qu'est une application web suffit.
Cette page s’adresse à quelqu’un qui découvre le sujet. Elle pose le vocabulaire qu’on retrouve partout ailleurs sur le site, avec un seul exemple du début à la fin : un paiement trop lent sur un site marchand.
Un paiement qui traîne
Section intitulée « Un paiement qui traîne »Imaginons une boutique en ligne. Le client clique sur « Payer ». D’habitude, la confirmation s’affiche en moins d’une seconde. Ce matin, certains clients attendent plusieurs secondes et quelques-uns abandonnent leur panier.
Le scénario est inventé et volontairement banal : c’est exactement le genre de problème que l’observabilité doit aider à résoudre.
Derrière le bouton « Payer », plusieurs programmes travaillent ensemble. On les appelle des services, chacun rend une fonction précise. Ici, le service checkout reçoit la commande et lit le panier dans une base de données. Il demande ensuite au service payment de faire valider le paiement par la banque.
flowchart LR
C["Client"] --> K["checkout"]
K --> DB[("Base panier")]
K --> P["payment"]
P --> B["API de la banque"]
La question est simple : pourquoi certains paiements sont-ils lents ?
Monitoring et observabilité
Section intitulée « Monitoring et observabilité »Le monitoring, ou supervision, ressemble au tableau de bord d’une voiture. On a choisi à l’avance quelques voyants : le taux d’erreur, le temps de réponse. On a fixé des seuils. Quand un seuil est franchi, une alerte part.
Ça marche très bien pour les questions prévues : le service répond-il ? Le temps de réponse dépasse-t-il deux secondes ?
Notre problème ne rentre pas dans ces cases. Seuls certains paiements sont lents. Peut-être ceux d’une banque précise, d’un pays, d’un type de carte. Personne n’avait prévu de voyant pour ça.
L’observabilité, c’est la capacité à répondre à une question qu’on n’avait pas prévue, en interrogeant les données déjà collectées, sans modifier le code ni attendre la prochaine mise en production. Cela suppose des données riches et reliées entre elles.
Les deux ne s’opposent pas. Le monitoring dit qu’il y a un problème, l’observabilité aide à comprendre lequel.
Les signaux
Section intitulée « Les signaux »Une application peut raconter ce qu’elle fait de plusieurs façons. On appelle ces récits des signaux. Trois sont classiques, deux autres complètent le tableau.
Les métriques : y a-t-il un problème ?
Section intitulée « Les métriques : y a-t-il un problème ? »Une métrique est un chiffre relevé à intervalle régulier, comme un compteur kilométrique qu’on noterait chaque minute : le nombre de paiements, leur durée moyenne.
Chaque métrique porte un nom et quelques précisions qu’on appelle des labels, par exemple le service concerné ou le résultat (réussi, en erreur). Les métriques prennent peu de place et se gardent longtemps. Elles alimentent les tableaux de bord et les alertes.
Dans notre exemple, une courbe montre que la durée des paiements grimpe depuis 9 h. Elle ne dit pas pourquoi.
Les traces : où est le temps perdu ?
Section intitulée « Les traces : où est le temps perdu ? »Une trace ressemble au suivi d’un colis : elle raconte le trajet d’une requête d’un service à l’autre, étape par étape, avec l’heure d’arrivée et de départ à chaque relais. Chaque étape s’appelle un span.
Les étapes s’emboîtent : celle du checkout contient celle du payment, qui contient l’appel à la banque. On voit d’un coup d’œil où le temps passe.
POST /checkout (checkout) |=========================================| 4 200 ms lecture du panier (base) |=| 70 ms autorisation (payment) |=======================================| 3 950 ms appel API banque (banque) |=====================================| 3 850 msLes durées sont illustratives. La trace montre que le service payment attend la banque. Le problème n’est ni dans la base ni dans le checkout.
Les logs : que s’est-il passé exactement ?
Section intitulée « Les logs : que s’est-il passé exactement ? »Un log est une ligne de journal de bord, datée, qui décrit un événement : « nouvelle tentative de connexion à la banque, délai dépassé ».
Un log rend plus de services quand il est écrit sous forme de champs (bank="banque-b", retry=2) plutôt qu’en phrase libre : on peut alors le filtrer et le compter, comme les colonnes d’un tableur.
Dans notre exemple, les logs du service payment montrent des tentatives répétées vers une seule banque. On tient la cause probable.
Les profils et les événements
Section intitulée « Les profils et les événements »Un profil mesure où un programme dépense son temps de calcul et sa mémoire, fonction par fonction. Il répond à la question « quelle partie du code coûte cher ? ». Dans OpenTelemetry, les profils sont encore en développement (documentation des signaux).
Un événement marque un fait ponctuel : un déploiement, un changement de configuration, une bascule vers un autre serveur. Posé sur une courbe, il répond à « qu’est-ce qui a changé à 9 h ? ».
| Signal | Question à laquelle il répond | Dans l’exemple |
|---|---|---|
| Métrique | Y a-t-il un problème, depuis quand, quelle ampleur ? | la durée des paiements monte depuis 9 h |
| Trace | Où, dans quel service, à quelle étape ? | le temps passe dans l’appel à la banque |
| Log | Que s’est-il passé exactement ? | des tentatives répétées vers une seule banque |
| Profil | Quel code consomme les ressources ? | utile si le service lui-même était lent |
| Événement | Qu’est-ce qui a changé ? | un déploiement du service payment à 8 h 55 |
Relier les signaux
Section intitulée « Relier les signaux »Pris séparément, chaque signal donne un morceau de l’histoire. L’intérêt apparaît quand on passe de l’un à l’autre en un clic : de la courbe qui monte à une requête lente, puis aux logs de cette requête précise.
Pour cela, chaque trace reçoit un numéro unique qui voyage avec la requête d’un service à l’autre, comme le numéro de suivi d’un colis. Si les logs portent aussi ce numéro, on retrouve en un instant les lignes de journal qui concernent la requête lente. Il faut aussi que tous les signaux désignent le service de la même façon, avec le même nom.
C’est précisément ce qu’apporte OpenTelemetry, le standard ouvert présenté dans OpenTelemetry de bout en bout : les mêmes identifiants et les mêmes noms pour tous les signaux.
flowchart LR M["Métrique<br/>durée des paiements"] -->|"exemplar"| T["Trace<br/>appel banque lent"] T -->|"trace id"| L["Logs<br/>tentatives répétées"] M -.->|"service.name"| L
Pour les équipes techniques : trace id, exemplars et attributs de ressource
Le numéro de trace s’appelle le trace id. Il circule dans un en-tête HTTP standardisé par le W3C (Trace Context). Une métrique peut aussi pointer vers une trace représentative : ce lien s’appelle un exemplar.
Le nom commun des services passe par les attributs de ressource, qui décrivent qui émet le signal : service.name, sa version, l’environnement, la machine. Si métriques, logs et traces portent les mêmes attributs, on les filtre tous de la même façon, par exemple service.name="payment".
La cardinalité en deux mots
Section intitulée « La cardinalité en deux mots »Une métrique se découpe en lignes, une par combinaison de labels : une ligne pour la banque A en réussite, une autre pour la banque A en erreur, etc. Avec 20 banques et 3 résultats possibles, on a au plus 60 lignes. Ajoutez l’identifiant du client avec 100 000 clients : ce nombre est multiplié par 100 000 (calcul illustratif). Le stockage, la lenteur et souvent la facture suivent (documentation Prometheus).
La règle que je recommande : un identifiant unique (client, commande, requête) va dans les traces et les logs, jamais dans les labels d’une métrique. La page La cardinalité expliquée raconte ce scénario en détail, avec une vidéo et un lab.
Pour aller plus loin
Section intitulée « Pour aller plus loin »- OpenTelemetry de bout en bout : suivre une étape de trace de l’application jusqu’au stockage.
- SLO et alerting : décider quand le paiement lent mérite de réveiller quelqu’un.
- Explorateur de traces : manipuler une vraie trace en cascade.
- Les couches de l’observabilité et l’architecture cliquable : voir où chaque signal est produit et stocké.
- Simulateur de cardinalité : mesurer l’effet d’un label sur vos propres chiffres.
- Le glossaire reprend tous les termes de cette page.
- OpenTelemetry, Signals : traces, métriques, logs, bagage et statut des profils et des événements.
- W3C, Trace Context : format de l’en-tête qui transporte l’identifiant de trace.
- Prometheus, Metric and label naming : chaque combinaison de labels crée une nouvelle série temporelle.