Un utilisateur signale qu'une action est "lente" en production. Les logs applicatifs ne montrent aucune erreur. Le dashboard de CPU est vert. Et pourtant, quelque chose cloche quelque part dans la chaîne entre la requête HTTP et la réponse. Ce scénario est le symptôme classique d'une application qui a des logs mais pas d'observabilité : on peut lire ce qui s'est passé à un endroit précis, mais on ne peut pas reconstituer le chemin complet d'une requête à travers le système. Ce billet détaille les trois piliers (logs, métriques, traces), ce que chacun révèle et ce qu'il cache, et comment les combiner pour diagnostiquer sans deviner.
Le problème : chaque pilier répond à une question différente
Les trois piliers de l'observabilité ne sont pas interchangeables :
- Les logs répondent à "que s'est-il passé, précisément, à cet instant, dans ce service ?". Ils sont riches en contexte mais coûteux à stocker et difficiles à corréler entre services sans identifiant commun.
- Les métriques répondent à "quelle est la tendance globale ?" (taux d'erreur, latence p95, débit). Elles sont bon marché à stocker sur le long terme (agrégées) mais ne disent rien sur une requête individuelle.
- Les traces distribuées répondent à "où est passé le temps, pour cette requête précise, à travers tous les services qu'elle a traversés ?". Elles relient logs et métriques en donnant le fil d'Ariane d'une requête unique.
Le piège classique : une équipe qui n'a que des logs centralisés (ELK, Loki) pense être "observable", mais sans corrélation par identifiant de requête (trace_id) entre les services, elle ne peut reconstituer le chemin d'une requête lente qu'en recoupant des timestamps à la main - un exercice qui prend des heures et qui est faux dès que deux requêtes se chevauchent dans le temps.
Pourquoi ça arrive : l'instrumentation par silo
Chaque service logue dans son coin, avec son propre format, sans propager de contexte vers les services qu'il appelle. Un appel HTTP d'un service A vers un service B ne transporte aucune information permettant de relier les deux logs a posteriori. La latence totale perçue par l'utilisateur est la somme de plusieurs segments (temps réseau, temps en base de données, appel à un service tiers, sérialisation), et sans traçage distribué, cette décomposition n'existe nulle part - elle doit être reconstruite mentalement, en espérant que l'intuition soit juste.
Diagnostiquer : instrumenter avant d'avoir le problème
L'observabilité ne s'ajoute pas après l'incident, elle s'ajoute avant. OpenTelemetry est devenu le standard de facto pour instrumenter logs, métriques et traces de façon unifiée, avec des exportateurs vers la plupart des backends (Jaeger, Grafana Tempo, Datadog, etc.).
Propager le contexte de trace entre services
// Node.js / Express - instrumentation OpenTelemetry minimale
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
const sdk = new NodeSDK({
traceExporter: new OTLPTraceExporter({
url: 'http://otel-collector:4318/v1/traces',
}),
instrumentations: [getNodeAutoInstrumentations()],
});
sdk.start();
Avec l'instrumentation automatique activée, chaque appel HTTP sortant propage automatiquement l'en-tête traceparent (format W3C Trace Context) vers le service appelé, qui continue la même trace plutôt que d'en démarrer une nouvelle.
Lier logs et traces par un identifiant commun
// Logger structuré (pino) qui injecte le trace_id courant dans chaque log
const pino = require('pino');
const { trace } = require('@opentelemetry/api');
const logger = pino({
mixin() {
const span = trace.getActiveSpan();
if (!span) return {};
const { traceId, spanId } = span.spanContext();
return { trace_id: traceId, span_id: spanId };
},
});
logger.info({ orderId: '8421' }, 'Commande créée avec succès');
// => {"level":30,"trace_id":"a1b2c3...","span_id":"d4e5f6...","orderId":"8421","msg":"Commande créée avec succès"}
À partir de ce moment, n'importe quel log applicatif peut être retrouvé à partir d'une trace lente dans Jaeger ou Tempo, et inversement : on peut cliquer sur un trace_id dans un log d'erreur pour voir la trace complète de la requête qui l'a produite.
Instrumenter manuellement les segments critiques
L'instrumentation automatique capture les appels HTTP et les requêtes SQL standard, mais pas la logique métier interne. Pour une étape coûteuse (calcul de recommandation, appel à une règle métier complexe), un span manuel donne la granularité nécessaire :
const { trace } = require('@opentelemetry/api');
const tracer = trace.getTracer('order-service');
async function calculateShippingCost(order) {
return tracer.startActiveSpan('calculate-shipping-cost', async (span) => {
span.setAttribute('order.id', order.id);
span.setAttribute('order.itemCount', order.items.length);
try {
const cost = await shippingRulesEngine.evaluate(order);
span.setAttribute('shipping.cost', cost);
return cost;
} catch (err) {
span.recordException(err);
span.setStatus({ code: 2, message: err.message }); // ERROR
throw err;
} finally {
span.end();
}
});
}
En visualisant la trace dans Jaeger, ce span apparaît comme un segment distinct dans la timeline de la requête, avec sa propre durée, ce qui permet de voir immédiatement s'il représente 5 ms ou 2 secondes sur une requête totale de 2,1 secondes.
Les métriques : la détection, pas le diagnostic
Les métriques (via Prometheus, par exemple) servent à détecter qu'un problème existe, pas à l'expliquer. Une alerte sur la latence p95 déclenche l'investigation ; la trace individuelle d'une requête lente, capturée au même moment, fournit l'explication.
// Histogramme Prometheus pour la latence par endpoint
const client = require('prom-client');
const httpDuration = new client.Histogram({
name: 'http_request_duration_seconds',
help: 'Durée des requêtes HTTP',
labelNames: ['method', 'route', 'status_code'],
buckets: [0.01, 0.05, 0.1, 0.3, 0.5, 1, 2, 5],
});
app.use((req, res, next) => {
const end = httpDuration.startTimer({ method: req.method });
res.on('finish', () => {
end({ route: req.route?.path ?? 'unknown', status_code: res.statusCode });
});
next();
});
L'intérêt des buckets explicites est de pouvoir calculer des percentiles (p50, p95, p99) côté Prometheus/Grafana sans stocker chaque valeur individuelle, ce qui serait ingérable en volume sur un service à fort trafic.
Les compromis
Le traçage distribué complet a un coût réel : volume de données à stocker, overhead CPU de l'instrumentation (généralement faible avec OpenTelemetry mais non nul), et complexité opérationnelle supplémentaire (collecteur OTel à maintenir, rétention à gérer). Tracer 100 % des requêtes sur un service à très fort trafic devient vite coûteux en stockage ; la pratique courante est l'échantillonnage (sampling), en gardant 100 % des traces en erreur et un pourcentage réduit des traces en succès.
// Échantillonnage basé sur le statut : garder toutes les erreurs, 10% du reste
const { TraceIdRatioBasedSampler, ParentBasedSampler } = require('@opentelemetry/sdk-trace-base');
const sdk = new NodeSDK({
sampler: new ParentBasedSampler({
root: new TraceIdRatioBasedSampler(0.1),
}),
// ...
});
Quand l'observabilité "standard" ne suffit pas
Pour des problèmes de performance intermittents et non reproductibles à volonté, même une trace détaillée peut ne rien montrer si l'échantillonnage n'a pas capturé l'occurrence problématique. Dans ce cas, le profiling continu (continuous profiling, via des outils comme Pyroscope ou Parca) complète les trois piliers en donnant une vue au niveau du code (quelle fonction consomme du CPU) sur une fenêtre de temps, sans attendre qu'une requête spécifique déclenche une alerte.
Le point à retenir : les logs expliquent un événement, les métriques détectent une tendance, les traces relient les deux à travers les services. Sans propagation de contexte (trace_id commun) entre ces trois piliers, chacun reste une île qu'il faut recouper à la main - exactement le travail que l'observabilité est censée éliminer.
