Pourquoi OpenTelemetry divise les développeurs

OTel a gagné la guerre du transport, pas celle de la pratique. Collector, conventions sémantiques et cardinalité : pourquoi le standard fracture les équipes.

Pourquoi OpenTelemetry divise les développeurs

Un protocole, trois signaux, zéro agent propriétaire : sur le papier, OpenTelemetry devait enterrer la guerre des APM. Six ans après la fusion d'OpenTracing et d'OpenCensus, la bataille n'a pas disparu. Elle s'est déplacée vers le YAML du Collector et les renommages de la spec.

Le transport est standardisé, la pratique ne l'est pas

Sur le papier, tout le monde a perdu et OpenTelemetry a gagné. Datadog, New Relic, Grafana, Honeycomb et Elastic acceptent tous de l'OTLP en entrée. Ce consensus est réel et il t'évite le lock-in sur les SDK.

Mais un standard de transport ne dit rien de la qualité des données que tu envoies. Deux équipes peuvent parler OTLP et produire des télémétries incompatibles. L'une nomme ses services api-prod-eu, l'autre backend : aucune requête commune ne sera possible sans table de correspondance.

La définition officielle parle d'un framework « vendor-neutral ». C'est exact sur les SDK, beaucoup moins sur les backends. Ton fournisseur reste maître du stockage, des tarifs et des requêtes.

Le Collector, chef-d'œuvre et piège à configuration

Le Collector est la meilleure et la pire idée du projet. C'est un binaire unique qui reçoit, transforme et exporte, et c'est aussi plusieurs centaines de lignes de YAML avant de voir une seule trace.

Un pipeline minimal tient pourtant en quinze lignes. Voilà ce que je déploie par défaut, avec les deux processeurs qui évitent 90 % des incidents :

receivers:
  otlp:
    protocols:
      grpc: { endpoint: 0.0.0.0:4317 }
      http: { endpoint: 0.0.0.0:4318 }

processors:
  memory_limiter:
    check_interval: 1s
    limit_mib: 512
  batch:
    timeout: 5s

exporters:
  otlphttp:
    endpoint: https://otlp.example.com

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [otlphttp]

Sans memory_limiter, un pic de trafic fait gonfler le Collector jusqu'à l'OOM kill. Sans batch, tu paies un appel réseau par span et ta facture de sortie explose.

La documentation du Collector est bonne, mais elle décrit les briques, pas l'ordre dans lequel les assembler. C'est ce vide que les intégrateurs remplissent avec des opinions divergentes.

Les conventions sémantiques, vrai champ de bataille

Le point de rupture n'est pas le code, ce sont les noms d'attributs. La spec HTTP a renommé http.status_code en http.response.status_code avec la version 1.23 des conventions sémantiques.

Concrètement, ton dashboard de taux d'erreur devient vide du jour au lendemain. Aucun crash, aucune alerte, juste une courbe plate que personne ne regarde avant l'incident suivant. J'ai vu cette panne silencieuse coûter une nuit de post-mortem à une équipe de cinq personnes.

La page des conventions sémantiques documente les statuts stable, experimental et deprecated. Le piège : les SDK émettent encore massivement de l'expérimental, et rien ne t'avertit quand un attribut bascule.

La parade tient en une règle d'équipe : toute mise à jour de SDK se teste sur un environnement de recette avec un diff de cardinalité. Pas de mise à jour en production sans comparaison des attributs émis.

La facture, angle mort du discours officiel

OpenTelemetry ne réduit pas le volume de données, il le rend portable. C'est une nuance que le marketing efface, et la réalité des factures la rappelle vite : instrumentation standardisée et modèle tarifaire du backend sont deux décisions séparées.

Le générateur de métriques de spans est le coupable habituel. Une seule métrique traces_spanmetrics_latency_bucket peut créer des dizaines de milliers de séries dès que tu ajoutes un label par route ou par client.

Les backends vendent la solution à leur propre problème. Grafana propose des règles Adaptive Metrics qui agrègent les labels inutiles, avec des gains annoncés de 30 à 50 % sur la cardinalité. Tu paies donc un outil pour corriger un volume que ton instrumentation a créé.

L'objection des sceptiques tient debout

« OpenTelemetry est un protocole, pas un produit » : la critique est juste et elle explique une bonne part de la fatigue. Tu obtiens un standard, pas un stockage, pas une UI, pas une gestion de rétention. Il te faut quand même un backend, et souvent un second pour les logs.

Deuxième objection, plus solide : le coût d'exploitation. Un Collector en gateway, c'est du CPU, de la mémoire, des montées de version et un fichier de configuration à réviser à chaque nouveau service. Pour une équipe de trois développeurs, un agent managé fait le travail avec deux lignes de configuration.

Troisième objection, la plus honnête : la promesse d'un « observability mesh » gratuit n'existe pas. OTel déplace la complexité vers toi, il ne la supprime pas. Ce transfert se justifie seulement si tu as plusieurs backends ou une vraie exigence de portabilité.

Ces trois arguments ne disqualifient pas le projet, ils le recadrent. Le standard résout l'interopérabilité, pas l'observabilité. Confondre les deux, c'est signer pour un chantier sans en mesurer la fin.

Mon avis : standardise la sortie, pas toute la télémétrie

Ma position est tranchée : OTel au niveau du SDK, prudence sur le reste. Instrumente avec les SDK officiels pour ne jamais dépendre d'un agent propriétaire, puis exporte en OTLP vers ce que tu veux.

En revanche, ne réécris pas ton pipeline pour le plaisir de la pureté. Si ton APM actuel ingest correctement l'OTLP et que la facture tient, garde-le. Le passage complet au Collector se justifie quand tu as besoin de filtrer, d'échantillonner ou de router vers plusieurs destinations.

Ce qui divise les développeurs n'est donc pas la technique, c'est la promesse. Ceux qui attendaient un produit clé en main sont déçus, ceux qui voulaient un contrat d'interface sont satisfaits. Le même outil, deux attentes, un débat qui n'en finit pas.

Le débat est d'ailleurs documenté ailleurs sur ce blog : j'ai déjà écrit sur la façon dont l'observabilité redéfinit les standards. Le pattern est identique, la valeur vient du modèle de données, pas de l'outil.

Le minimum viable pour ne pas se noyer

Si tu démarres aujourd'hui, quatre décisions suffisent à éviter les pièges les plus chers.

  • Un service.name stable et documenté : c'est la clé de jointure entre traces, métriques et logs. Change-le et tu perds l'historique.
  • Un échantillonnage au Collector, pas au SDK : le tail sampling garde les traces en erreur et jette le reste. C'est la seule façon de garder de la valeur à volume constant.
  • Une version de semconv figée par équipe : monte-la comme une dépendance, avec un test de non-régression sur les attributs critiques.
  • Un plafond de cardinalité par métrique : au-delà de 10 000 séries, le label fautif part en revue.

Le déploiement de ces composants sur Kubernetes a lui aussi ses pièges, que j'ai détaillés dans le guide des Ingress. Un Collector exposé sans memory_limiter tombe exactement comme un pod sans requests.

Ce que je retiens

OpenTelemetry divise parce qu'il demande un arbitrage explicite : combien de complexité tu acceptes en échange de ta liberté de backend. Ceux qui refusent l'arbitrage subissent le YAML, ceux qui l'assument construisent un pipeline qui survit aux changements de fournisseur.

Le standard a déjà gagné la guerre du transport. La prochaine se joue sur les conventions et la facture, et elle sera moins consensuelle.