Aller au contenu

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.

Mode de lecture

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.

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 ?

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.

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.

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.

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 ms

Les 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.

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.

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 ? ».

SignalQuestion à laquelle il répondDans l’exemple
MétriqueY a-t-il un problème, depuis quand, quelle ampleur ?la durée des paiements monte depuis 9 h
TraceOù, dans quel service, à quelle étape ?le temps passe dans l’appel à la banque
LogQue s’est-il passé exactement ?des tentatives répétées vers une seule banque
ProfilQuel code consomme les ressources ?utile si le service lui-même était lent
ÉvénementQu’est-ce qui a changé ?un déploiement du service payment à 8 h 55

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".

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.

  • 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.