Comment l'observabilité redéfinit les standards
Ta facture de télémétrie en dit plus sur ton architecture que tes dashboards. Trois règles appliquées sur quatre services : -62 % de coût, diagnostic en 9 minutes.
Le premier incident que l'observabilité m'a évité ne ressemblait pas à un incident. C'était une courbe de facture : 4 800 dollars par mois de télémétrie pour un service qui encaissait 12 requêtes par seconde. Jamais un système n'avait été aussi bien instrumenté, et jamais je n'avais aussi mal compris ce qu'il faisait.
C'est là que le débat sur les standards se joue vraiment. Pas dans le choix entre Datadog et Grafana, mais dans la question qu'on accepte de se poser avant d'ajouter la millième métrique.
Le monitoring n'est pas mort, il a perdu la bataille du pourquoi
Un dashboard classique te dit que le CPU est à 87 %. Il ne te dit pas quel client a provoqué la hausse, ni depuis quand, ni ce qu'il perd pendant ce temps. Pendant des années, on a compensé avec de l'expérience et des intuitions : « c'est sûrement le batch de 3 h ».
Sur une architecture monolithique, l'intuition suffisait. Sur douze services qui s'appellent en cascade, elle devient une pièce de théâtre. Tu fixes un graphe, tu racontes une histoire, et l'incident continue.
Cas concret : une lenteur sur un tunnel de paiement, aucune alerte déclenchée, p99 qui glisse de 400 ms à 1,2 s en trois semaines. La cause n'était ni le CPU ni la base, mais un client B2B qui poussait des paniers de 8 Mo de photos.
Aucune métrique agrégée ne pouvait le montrer : il fallait une trace portant l'attribut tenant.id et payload.size. Trois semaines de dégradation pour une ligne d'instrumentation manquante.
Les trois piliers sont une taxonomie de vendeur, pas une vérité technique
Métriques, logs, traces : ce découpage est né des produits, pas des problèmes. Il t'oblige à choisir un silo avant de savoir ce que tu cherches, et à recoller à la main ce que le système avait déjà vu ensemble.
Mon opinion est tranchée : l'unité utile n'est pas la métrique, c'est l'événement large. Un span qui porte le tenant, la route, le statut, la durée, la version de code et le flag activé remplace trois dashboards et deux recherches de logs.
Le guide de monitoring infra pose déjà les bases de cette collecte ; ce qui a changé, c'est le coût de la corrélation. Une requête sur 40 attributs dans un stockage colonne coûte quelques centimes. La même enquête à la main dans trois outils coûte une demi-journée d'astreinte.
L'instrumentation est devenue du code produit
Le déplacement le plus profond n'est pas technologique, il est organisationnel. L'instrumentation n'appartient plus à l'équipe ops : elle est écrite, relue et versionnée par ceux qui écrivent la feature.
Concrètement, ça tient en un middleware et une règle de revue. Le middleware ouvre le span et injecte le contexte ; la règle exige au moins un attribut métier par nouvelle route.
from opentelemetry import trace
tracer = trace.get_tracer("checkout")
def traced_checkout(tenant, cart):
with tracer.start_as_current_span("checkout.validate") as span:
span.set_attribute("tenant.id", tenant.id)
span.set_attribute("tenant.plan", tenant.plan) # free | pro | scale
span.set_attribute("cart.items", len(cart.items))
span.set_attribute("cart.payload_bytes", cart.size_bytes)
return validate(cart)Ces quatre attributs ont résolu l'incident du tunnel de paiement en une requête. Aucun dashboard supplémentaire, aucune réunion.
La contrepartie est réelle : chaque attribut ajouté est une décision de production qu'un développeur prend seul, souvent sans mesurer l'explosion de cardinalité qui suit. Sur un service en microservices, cette dette se paie en facture et en latence de requête.
Le coût est le standard caché que personne n'écrit
La cardinalité est la seule loi physique de l'observabilité. Chaque attribut à valeurs nombreuses multiplie les séries, et le produit croît de façon brutale.
Exemple vécu sur Prometheus : un attribut user_id ajouté « juste pour déboguer » sur une route à 40 000 utilisateurs actifs a fait passer l'instance de 180 000 à 6,2 millions de séries actives. Mémoire multipliée par sept, scrape qui dépasse le timeout, alertes muettes pendant deux jours.
Les standards sérieux ont donc migré vers trois garde-fous : un budget de cardinalité par service, un échantillonnage en tête pour le volume, et un échantillonnage en queue pour ne jamais perdre les erreurs. Garder 100 % des traces en erreur et 1 % des succès divise la facture par vingt sans dégrader le diagnostic.
L'objection qui tient debout : « on ne peut pas prédire les questions »
C'est l'argument le plus solide contre l'échantillonnage, et il mérite mieux qu'un haussement d'épaules. Si tu ne sais pas ce que tu chercheras demain, échantillonner revient à parier sur les questions de la semaine prochaine.
Ma réponse est partielle, et je l'assume : le stockage objet a rendu les traces complètes abordables, mais il n'a pas rendu les requêtes gratuites. Scanner deux téraoctets par jour pour retrouver un tenant coûte plus cher que de conserver intelligemment les spans qui portent une anomalie.
Le compromis opérationnel : 100 % des erreurs, 100 % des requêtes lentes au-delà du p99, 1 % du trafic nominal, et une fenêtre courte en rétention chaude. Le reste part en archive froide, consultable mais lente — ce qui est exactement le bon prix pour une question rétrospective.
Second point : pour la question « pourquoi ce processus brûle du CPU », la trace est le mauvais outil. Le profilage continu répond en trente secondes là où une trace distribuée ne montre qu'une durée. Le standard a changé là aussi : OpenTelemetry a normalisé les signaux pour que profils, métriques et traces partagent le même contexte.
Ce que je fais différemment depuis
Trois règles, appliquées sur quatre services en production, ont fait baisser la facture de 62 % et le temps moyen de diagnostic de 45 à 9 minutes.
Première règle : trois SLO maximum par service, jamais plus. Un SLO de disponibilité, un de latence, un de fraîcheur de traitement. Le reste est du bruit qui dilue l'attention.
Deuxième règle : on alerte sur le symptôme, pas sur la cause. Le taux d'erreur et le p99 réveillent quelqu'un ; le CPU ne réveille personne. Un CPU à 95 % qui sert correctement les requêtes est un problème de capacité, pas un incident.
Troisième règle : tout dashboard non ouvert depuis trente jours est supprimé sans débat. Cette règle seule a retiré 41 dashboards et 900 alertes mortes. Le chapitre monitoring du SRE Book de Google dit la même chose autrement : les alertes doivent correspondre à une douleur réelle pour l'utilisateur.
Le standard n'est plus l'outil, c'est le délai de réponse
La vraie rupture tient en une phrase : on ne mesure plus la qualité de l'observabilité au nombre de graphes, mais au temps nécessaire pour répondre à une question inédite.
Cette bascule déplace la responsabilité vers l'équipe produit et rend l'astreinte beaucoup moins théâtrale. Tu ouvres une trace, tu lis les attributs, tu sais. Le reste — la taxonomie des piliers, les dashboards, la guerre des vendors — devient de la décoration.
Le consensus actuel de l'industrie va dans ce sens, comme le résume la définition opérationnelle de Honeycomb : la capacité à répondre à des questions imprévues sans redéployer. C'est exigeant, c'est coûteux, et c'est très loin d'un simple changement d'outil.