Le vrai coût de l'observabilité
Ta facture d'observabilité ne suit pas ton trafic, elle suit ta cardinalité. Où part l'argent, et les trois chiffres à sortir avant de renégocier.
Le prix affiché n'est jamais la facture
Datadog annonce 15 $ par hôte et par mois en Infrastructure Pro. Sur une flotte de 300 machines, ça fait 4 500 $ avant même d'avoir indexé le moindre log.
Le reste arrive par la porte de derrière. Les métriques custom se facturent par paquets de 100 à 5 $ par mois, les logs à l'ingestion puis une seconde fois à l'indexation, les spans OTLP à 0,50 $ le Go chez Datadog comme ailleurs. Le tarif d'entrée est un teaser, pas un budget.
J'ai vu une équipe de huit ingénieurs tripler sa facture en un trimestre sans ajouter un seul serveur. Le trafic n'avait pas bougé, l'instrumentation avait juste grandi.
La cardinalité, cette fuite silencieuse
Une métrique ne se facture pas à sa valeur mais au nombre de séries temporelles uniques qu'elle produit. Prends http_request_duration_seconds{route, method, status, user_id} sur une app avec 50 000 utilisateurs actifs : 50 000 séries pour une seule métrique.
Les backends qui facturent à la série voient 70 à 90 % de leur facture partir dans les labels à forte cardinalité. Le label user_id n'a jamais servi à une alerte, mais il coûte chaque mois.
# prometheus.yml — tuer la cardinalité avant qu'elle n'atteigne le backend
metric_relabel_configs:
- source_labels: [__name__]
regex: 'http_request_duration_seconds'
action: keep
- regex: 'user_id|session_id|request_id'
action: labeldropTrois labels supprimés sur une métrique, et la facture mensuelle baisse de plusieurs centaines d'euros. Aucune alerte utile n'a disparu : les SLO se calculent sur route et status, pas sur l'identifiant d'un client.
Les logs indexés coûtent bien plus que les logs stockés
Cas concret : 200 Go de logs applicatifs par jour, dont 60 % de health checks Kubernetes et de lignes de debug oubliées. Indexer tout revient à payer deux fois, à l'entrée puis au stockage interrogeable.
La correction tient en un fichier de collecteur. Tu filtres les health checks à la source, tu réserves l'index à ce que tu requêtes vraiment, et tu envoies le reste en archive froide à un centième du prix.
# otelcol — rejeter le bruit avant l'ingestion
processors:
filter/drop_noise:
error_mode: ignore
logs:
log_record:
- 'IsMatch(body, "GET /healthz")'
- 'severity_number < SEVERITY_NUMBER_INFO'Sur ce volume, le filtrage naïf des health checks représente 15 à 20 % d'économie immédiate, sans toucher à une seule ligne de code applicatif.
Le coût que personne ne met dans le tableur
Il y a un deuxième poste, invisible dans la facture : le temps de cerveau. Quarante dashboards dont trois sont consultés, des alertes qui sonnent la nuit pour un CPU à 71 %, des runbooks que plus personne ne lit.
Une alerte qui ne déclenche pas d'action est une dette. Elle consomme de l'attention, elle entraîne l'équipe à ignorer les notifications, et elle finit par masquer l'incident qui compte. Ce coût-là ne figure sur aucune ligne de facture, mais il est souvent supérieur au premier.
Mon avis est tranché : la majorité des stacks d'observabilité que je croise sont des cimetières de métriques entretenus par habitude. On y ajoute des dashboards parce que c'est plus simple que de supprimer ceux qui mentent.
Le contre-argument : couper a aussi un prix
Réduire l'observabilité n'est pas gratuit. Un incident de quatre heures sur un service qui génère 20 000 € de chiffre d'affaires mensuel coûte plus cher que la facture annuelle d'observabilité d'une PME entière. Couper aveuglément, c'est échanger une ligne de dépense contre un MTTR qui explose.
Le bon arbitrage n'est donc pas « moins de données » mais « les bonnes données ». Garde 100 % des erreurs et des traces lentes, échantillonne le trafic nominal. Le tail-based sampling fait exactement ça : il décide après la fin de la trace, quand il sait qu'elle est anormale.
processors:
tail_sampling:
decision_wait: 10s
policies:
- name: erreurs
type: status_code
status_code: {status_codes: [ERROR]}
- name: lentes
type: latency
latency: {threshold_ms: 800}
- name: baseline
type: probabilistic
probabilistic: {sampling_percentage: 2}Résultat typique : 60 à 80 % de volume en moins, zéro perte sur les traces qui expliquent un incident. La nuance compte : un échantillonnage en tête de pipeline, avant de connaître le statut de la requête, aurait jeté la moitié de tes erreurs.
Trois chiffres à sortir avant de renégocier
Tu ne peux pas arbitrer sans mesurer. Trois ratios suffisent et se calculent en une heure depuis la page d'usage de ton fournisseur : coût par service, coût par signal (métriques, logs, traces), coût par incident évité.
Le troisième est le seul qui compte vraiment. Si un service te coûte 400 € par mois d'observabilité et qu'il n'a provoqué aucun incident en un an, pose la question à voix haute : que t'apprend ce dashboard ? Parfois la réponse est « rien », et c'est une réponse acceptable pour décider de réduire.
Regarde aussi le rapport entre la ligne métriques et la ligne logs. Dans neuf cas sur dix, les logs pèsent l'essentiel de la facture et proviennent de trois namespaces qui n'ont jamais été nettoyés depuis la migration.
Ce que je retiens
Le coût de l'observabilité n'est pas un problème de tarif fournisseur, c'est un problème de discipline d'instrumentation. Les entreprises qui paient cher paient rarement pour de la visibilité : elles paient pour des labels oubliés, des logs de debug et des dashboards morts.
Commence par la cardinalité, filtre les logs à la source, échantillonne en queue. Et vérifie une chose après chaque coupe : ton MTTR est-il resté stable ? Si oui, tu viens de gagner deux fois.
Pour creuser la partie outillage, j'ai détaillé les alternatives au monitoring classique et un cas pratique complet avec Grafana. Les tarifs cités viennent de la grille Datadog publique, la mécanique de facturation des métriques custom est documentée ici, et les leviers de réduction sont détaillés dans le guide Grafana Cloud.