Métriques

Ce que c'est

Les métriques sont des mesures d’un service en fonctionnement,
chacune prise à un instant et conservée comme valeur avec horodatage
et quelques étiquettes. La même quantité peut ainsi être relue une
minute, un jour ou un mois après. Une quantité nommée est une
métrique ; stockée en suite de valeurs dans le temps, elle devient
une série temporelle. OpenTelemetry classe les métriques parmi ses
signaux, à côté des traces et journaux. Requêtes servies, mémoire
utilisée et tâches en attente dans une file sont des exemples
typiques.

L’agrégation distingue les métriques des autres signaux. Un journal
garde une ligne par événement et une trace suit une requête dans le
système. Une métrique rassemble de nombreuses mesures en quelques
statistiques sur une fenêtre temporelle : compte, somme, valeur
actuelle, répartition par tranches. La documentation OpenTelemetry
qualifie le résultat d’information statistique agrégée : c’est sa
force et sa limite. Une métrique dit combien de requêtes ont échoué
la dernière minute ; un journal dit lesquelles.

OpenTelemetry et Prometheus s’accordent sur quelques formes ;
choisir la bonne constitue l’essentiel de la conception :

  * Un compteur cumule et ne fait que croître, comme le compteur
kilométrique d’une voiture : requêtes servies, octets envoyés,
erreurs constatées. Prometheus accepte une exception : la remise à
zéro au redémarrage du processus.

  * Un compteur bidirectionnel, selon la terminologie
d’OpenTelemetry, cumule mais peut aussi diminuer, comme la longueur
d’une file selon les arrivées et départs.

  * Une jauge est une valeur actuelle lue à l’instant de la mesure,
comme la jauge de carburant de la même voiture : mémoire utilisée,
température, requêtes en cours.

  * Un histogramme classe les mesures en tranches et conserve le
nombre de mesures et leur somme, pour dire combien de requêtes ont
duré moins d’une seconde.

Prometheus possède aussi un résumé, ou summary, qui calcule les
quantiles dans le programme. Le modèle OpenTelemetry ne le garde que
comme type hérité, car on ne peut pas toujours combiner utilement
les résumés.

Le format textuel collecté par Prometheus réunit ces éléments :
ligne d’aide, ligne de type, puis une ligne par combinaison
d’étiquettes avec le nom, les étiquettes, la valeur et un horodatage
facultatif en millisecondes depuis l’époque de référence.

```text
i# HELP http_requests_total The total number of HTTP requests.		engineer.company	70
i# TYPE http_requests_total counter		engineer.company	70
http_requests_total{method="post",code="200"} 1027 1395066363000
http_requests_total{method="post",code="400"} 3 1395066363000
```

Pourquoi c'est important

Les métriques coûtent assez peu pour tout mesurer. Leur mémoire
croît avec le nombre de combinaisons d’étiquettes distinctes, pas
avec le trafic ; la documentation OpenTelemetry le dit expressément,
en distinguant les métriques des journaux. Un compteur incrémenté un
milliard de fois reste un seul nombre. Une équipe peut ainsi compter
toutes les requêtes plutôt qu’un échantillon et garder ces comptes
assez longtemps pour comparer ce mois au précédent.

Elles transforment les débats en mesures. Un hôte est-il assez
grand, une version a-t-elle ralenti les réponses, quand un disque
sera-t-il plein ? Chaque réponse se trouve dans une série
enregistrée avant la question. Les alertes reposent sur les mêmes
nombres : leur règle est une condition sur une métrique jugée assez
importante pour réveiller quelqu’un.

Elles survivent aussi au code qui les émet : autant bien choisir
leur forme. Le guide de nommage Prometheus demande une unité et une
quantité par métrique, en unités de base comme secondes et octets
plutôt que millisecondes ou mégaoctets, avec l’unité au pluriel en
suffixe et `_total` pour un compte cumulatif. Des noms tels que
`http_request_duration_seconds` et `process_cpu_seconds_total`
annoncent ainsi leur contenu.

La circulation des totaux compte aussi. Prometheus rapporte des
totaux cumulatifs : les lacunes dues aux échecs intermittents de
collecte se compensent dans la moyenne, au prix d’une mémoire côté
émetteur proportionnelle aux combinaisons d’étiquettes. StatsD
rapporte des deltas, la variation depuis le dernier envoi, ce qui
sort ce coût du processus.

À quoi cela ressemble en pratique

L’hôte des services de l’entreprise accessibles au public est une
machine monocœur dotée de 512 Mo de mémoire, dont environ 464 Mo
utilisables ; la mémoire y est devenue le critère décisif. La
production de rapports fonctionne à la demande : sept commandes
lisent l’hôte et produisent du Markdown, ne modifient rien et ne
tournent que lorsqu’on les demande. Pour savoir si cet unique hôte
de 512 Mo pouvait aussi accueillir un service onion, la réponse est
venue d’une journée consignée d’échantillons mesurés : la mémoire
disponible n’est jamais passée sous environ 310 Mo sur 464, le swap
est resté à 2,6 % et le taux d’inactivité du processeur à 99,7 %.

Ces rapports ont ensuite dû dire ce que valaient leurs nombres. Six
collecteurs en lecture seule ont été amenés à indiquer ce qu’ils ne
lisaient pas lorsqu’il est apparu qu’une collecte aveugle et un hôte
sain produisaient la même page : un miroir dont le démon avait
changé le format du journal affichait le même zéro qu’un miroir sans
visite. Les seuils ont été ajustés aux 116 échantillons déjà mesurés
par le rapport de métriques, avec les plages observées notées à côté
des bornes. Le rapport distingue trois issues : dépassement, absence
de dépassement et non évalué faute de mesure. Chaque collecteur
indique sa durée d’exécution et ses angles morts, par exemple
fichiers lus et fichiers illisibles, même si la réponse est zéro.
Les bornes s’appliquent à des moyennes journalières, qui peuvent
masquer un pic d’une minute. Le dispositif exécuté toutes les quinze
minutes vérifie la mémoire disponible et l’espace disque libre à
chaque passage, mais un bref dépassement entre deux contrôles peut
encore passer inaperçu.

Les métriques les plus utiles viennent souvent du problème plutôt
que de l’hôte. La note sur la vente d’un stock limité sans survente
réunit sur un tableau de bord les attentes de verrou, réservations
expirées et écarts entre le compte du dispositif d’admission et
celui de la base. Elle exécute régulièrement l’invariant `available
+ held + sold = total`, tracé sur un graphique et signalé par une
alerte d’astreinte à toute dérive. Chacun de ces nombres vient de la
compréhension des échecs possibles de cette vente.

Où les problèmes surviennent

Les métriques se dérèglent rarement de façon manifeste. Le graphique
continue de s’afficher, mais le nombre qu’il montre signifie
discrètement autre chose que ce que son nom indique.

Une valeur décroissante est publiée comme compteur. La page des
types Prometheus dit de ne pas utiliser de compteur pour une valeur
pouvant diminuer, comme le nombre de processus actifs : c’est une
jauge. Les fonctions de requête traitent toute baisse comme un
redémarrage et la corrigent : une baisse voulue apparaît donc comme
une hausse qui n’a jamais eu lieu.

Les unités divergent entre services. Un service rapporte une durée
en millisecondes, un autre en secondes : le panneau les comparant se
trompe d’un facteur mille. Le guide demande une seule unité par
métrique et recommande les unités de base. Convertir une fois à la
source coûte moins que se rappeler la différence dans chaque
requête.

Une somme sur les étiquettes n’a aucun sens. La règle pratique du
guide est que la somme ou moyenne sur toutes les étiquettes d’une
métrique devrait avoir un sens. Son exemple : les capacités de
plusieurs files appartiennent à une même métrique, mais pas la
capacité d’une file et sa longueur actuelle.

L’absence de mesure se lit comme zéro. Un collecteur ne lisant plus
ses entrées laisse un zéro ou une ligne absente, qui donnent
exactement l’apparence d’un système calme. Le modèle OpenTelemetry
porte un indicateur de point sans valeur enregistrée, équivalent du
marqueur de péremption de Prometheus, car données absentes et valeur
nulle sont deux faits différents. Présentez-les différemment et
donnez une issue propre à « non évalué », comme les collecteurs
ci-dessus.

La fenêtre masque le pic. Une jauge est un échantillon instantané ;
le modèle OpenTelemetry ne rapporte que la dernière valeur de chaque
intervalle. Une rafale entre deux échantillons ne laisse donc aucune
trace. Une moyenne journalière efface de même une minute au plafond.
Choisissez la fenêtre selon la défaillance à voir et gardez un
contrôle rapide à côté d’un lent si les deux comptent.

Le débordement entraîne un sous-comptage dans une requête filtrée.
Par défaut, le SDK OpenTelemetry suit au plus 2 000 combinaisons
d’attributs distinctes par flux de métriques et regroupe les
suivantes en un point unique marqué `otel.metric.overflow=true`. Le
total reste juste, mais le débordement remplace la combinaison
entière, pas seulement sa partie bruyante. Dans l’exemple de la
documentation, un compteur de requêtes porte `url.path` et
`success` ; après débordement, une requête sur `success=false`
renvoie un compte trop faible et une alerte de taux d’erreur fondée
dessus peut cesser de se déclencher. Limitez les attributs à de
petits ensembles connus et surveillez le marqueur de débordement.

Pour aller plus loin

  * OpenTelemetry : métriques — types d’instruments, agrégation et
limite de cardinalité.

  * OpenTelemetry : modèle de données des métriques — jauges,
sommes, histogrammes, temporalité et indicateur d’absence de valeur
enregistrée.

  * Prometheus : types de métriques — compteur, jauge, histogramme
et résumé.

  * Prometheus : nommage des métriques et étiquettes — unités de
base, suffixes d’unités et `_total`.

  * Prometheus : histogrammes et résumés — lieu de calcul des
quantiles et possibilité de les combiner.

  * Prometheus : formats d’exposition — le format textuel ligne par
ligne.

hCette page sur le Web	URL:https://engineer.company/fr/glossary/metrics/	engineer.company	70
