Aller au contenu

TechniqueExpert6 min de lecture

Partie II. Architecture et configurations de référence

Faire passer les signaux de l'IA par le même circuit que le reste du système : le plan de collecte unifié, une configuration de référence du Collector et des recording rules MetricsQL pour la latence, les erreurs et le coût.

Pour : ingénieurs et SRE · architectesPrérequis : Avoir lu la partie I ; connaître l'OpenTelemetry Collector et le langage PromQL ou MetricsQL.

Scénario illustratif : l’équipe qui construit le nouvel assistant installe son propre outil de suivi des appels au modèle, à côté de la supervision que l’exploitation utilise déjà pour les serveurs et les bases. Un soir, les réponses ralentissent. L’équipe IA voit des appels lents, l’exploitation voit une base vectorielle saturée. Il leur faut une heure au téléphone pour comprendre qu’elles regardent le même incident sous deux angles.

Je recommande de ne pas construire de stack GenAI en silo. Les traces, métriques et logs des LLM, des agents, des RAG et de MCP doivent passer par le même circuit que ceux de l’infrastructure et des applications existantes, comme le courrier d’un nouveau service qui passe par le même bureau de tri que le reste de l’entreprise. On appelle ce circuit commun le plan de collecte.

La méthode ne dépend d’aucun outil. VictoriaMetrics, Grafana et Langfuse forment ici un exemple parmi d’autres, retenu parce qu’il s’auto-héberge et repose sur des protocoles ouverts (OTLP, le protocole d’OpenTelemetry ; remote write, celui qui sert à pousser des métriques vers une base). Les mêmes rôles se tiennent avec Prometheus, Mimir ou Thanos pour les métriques, Tempo ou Jaeger pour les traces, Loki pour les logs, Phoenix (sous Elastic License 2.0, une licence source disponible) ou un service commercial comme LangSmith pour l’évaluation. Langfuse appartient à ClickHouse depuis janvier 2026 ; son cœur reste sous licence MIT.

Le schéma suit le trajet d’un signal. L’application est instrumentée, c’est-à-dire équipée de bibliothèques qui décrivent ce qu’elle fait (OpenLLMetry, OpenInference ou le SDK natif). Ces descriptions arrivent au Collector d’OpenTelemetry, un programme intermédiaire qui trie, nettoie et redistribue. Le Collector masque les données sensibles, puis envoie chaque signal vers le stockage qui lui convient. Grafana affiche le tout.

flowchart TB
  APP["Application : LLM / Agent / RAG / Clients MCP"]
  INST["Instrumentation OTel<br/>OpenLLMetry, OpenInference, SDK natif"]
  COL["OpenTelemetry Collector<br/>masquage, attributs, spanmetrics"]
  MET["Métriques<br/>VictoriaMetrics<br/>(DCGM, vLLM)"]
  TRA["Traces<br/>backend OTLP"]
  LOG["Logs<br/>VictoriaLogs / Loki"]
  CON["Contenu opt-in<br/>stockage objet chiffré"]
  EVAL["Couche évaluation<br/>Langfuse / Phoenix"]
  GRAF["Grafana<br/>tableaux de bord, alerting, SLO"]
  APP --> INST --> COL
  COL --> MET
  COL --> TRA
  COL --> LOG
  COL --> CON
  MET --> GRAF
  TRA --> GRAF
  LOG --> GRAF
  TRA --> EVAL
  CON --> EVAL
  EVAL --> GRAF

Le Collector travaille comme un poste de contrôle à l’entrée d’un entrepôt. Il reçoit les colis (les signaux), retire ce qui ne doit pas entrer (les adresses e-mail, les numéros de carte), puis oriente chaque colis vers le bon rayon.

La configuration proposée, à adapter, organise ce travail en trois chaînes de traitement qu’on appelle des pipelines : une pour les traces, une pour les métriques, une pour les logs. Elle masque les données sensibles avant tout envoi. Elle fabrique aussi des métriques à partir des traces, grâce à un composant nommé spanmetrics : chaque étape de trace (un span) est comptée et chronométrée, puis rangée par modèle, par type d’opération, par agent et par type d’erreur. On se limite volontairement à ces dimensions à faible cardinalité, c’est-à-dire qui prennent peu de valeurs différentes, pour ne pas faire exploser le nombre de séries stockées.

Un détail compte. Si une instrumentation capture par erreur le contenu des messages, un filtre le retire des spans avant leur export. Le contenu choisi en opt-in passe par un stockage externe chiffré, jamais par le backend de traces.

Pour les équipes techniques : le fichier otel-collector.yaml commenté
# otel-collector.yaml (extrait de référence)
receivers:
otlp:
protocols:
grpc: { endpoint: 0.0.0.0:4317 }
http: { endpoint: 0.0.0.0:4318 }
processors:
batch:
timeout: 5s
send_batch_size: 1000
# Masquage : on retire ou hache le contenu sensible avant tout export.
redaction:
allow_all_keys: true
blocked_values:
- "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}" # emails
- "\\b(?:\\d[ -]*?){13,16}\\b" # numéros de carte
summary: info
# Filet de sécurité sur les traces : si une instrumentation capture le
# contenu par erreur, on le retire des spans avant export. Le contenu opt-in
# passe par le stockage externe chiffré, jamais par le backend de traces.
# Les métriques n'ont pas besoin de ce filtre : spanmetrics ne garde que les
# dimensions listées ci-dessous.
attributes/clean:
actions:
- key: gen_ai.input.messages
action: delete
- key: gen_ai.output.messages
action: delete
connectors:
# Dérivation de métriques depuis les spans, dimensions low-cardinality.
spanmetrics:
dimensions:
- name: gen_ai.request.model
- name: gen_ai.operation.name
- name: gen_ai.agent.name
- name: error.type
exporters:
# Métriques vers VictoriaMetrics (endpoint remote write).
prometheusremotewrite:
endpoint: http://victoriametrics:8428/api/v1/write
# Traces vers le backend OTLP.
otlp/traces:
endpoint: tempo:4317
tls: { insecure: true }
# Logs vers VictoriaLogs ou Loki.
otlphttp/logs:
logs_endpoint: http://victorialogs:9428/insert/opentelemetry/v1/logs
service:
pipelines:
traces:
receivers: [otlp]
processors: [attributes/clean, redaction, batch]
exporters: [otlp/traces, spanmetrics]
metrics:
receivers: [otlp, spanmetrics]
processors: [batch]
exporters: [prometheusremotewrite]
logs:
receivers: [otlp]
processors: [redaction, batch]
exporters: [otlphttp/logs]

Calculer à chaque affichage la latence de tous les appels du dernier mois, c’est comme recompter toute la caisse d’un magasin chaque fois qu’on veut connaître le chiffre du jour. Une recording rule fait ce calcul à intervalle régulier puis range le résultat sous un nouveau nom. Les tableaux de bord et les alertes lisent ensuite ce résultat déjà prêt.

La méthode propose cinq règles, à poser dans VictoriaMetrics ou un Prometheus compatible, écrites en MetricsQL (le langage de requête de VictoriaMetrics, proche de PromQL). Elles calculent la latence au 95e centile par modèle, c’est-à-dire le temps sous lequel passent 95 % des appels. Elles calculent aussi le TTFT au même centile pour les appels en streaming, le taux d’erreur par type d’erreur, le coût estimé par seconde et le nombre moyen de jetons d’entrée par requête. Ce dernier chiffre sert à repérer le gonflement du prompt : s’il double en un mois, quelqu’un a ajouté beaucoup de texte quelque part.

Les métriques sources sont celles des conventions OTel GenAI 1.40 et 1.41 (gen_ai.client.operation.duration, gen_ai.client.token.usage et gen_ai.client.operation.time_to_first_chunk à partir de la 1.41). Leurs noms changent en route. Par défaut (translation_strategy: UnderscoreEscapingWithSuffixes), l’exportateur prometheusremotewrite remplace les points par des tirets bas et ajoute le suffixe d’unité. gen_ai.client.operation.duration (unité s) devient donc gen_ai_client_operation_duration_seconds_bucket, _sum et _count. L’unité {token} est une simple annotation et ne produit pas de suffixe : gen_ai_client_token_usage_sum reste tel quel. Si vous choisissez UnderscoreEscapingWithoutSuffixes, retirez _seconds des règles. Les prix sont à prendre dans votre propre table datée (annexe D).

Pour les équipes techniques : le fichier rules.yaml
# rules.yaml (extrait de référence, syntaxe MetricsQL)
groups:
- name: genai
interval: 30s
rules:
# Latence p95 par modèle : durée d'opération.
- record: genai:operation_duration:p95
expr: |
histogram_quantile(0.95,
sum(rate(gen_ai_client_operation_duration_seconds_bucket[5m])) by (le, gen_ai_request_model))
# TTFT p95 par modèle : délai avant le premier fragment, appels en streaming seulement.
- record: genai:time_to_first_chunk:p95
expr: |
histogram_quantile(0.95,
sum(rate(gen_ai_client_operation_time_to_first_chunk_seconds_bucket[5m])) by (le, gen_ai_request_model))
# Taux d'erreur par type d'erreur.
- record: genai:error_ratio
expr: |
sum(rate(gen_ai_client_operation_duration_seconds_count{error_type!=""}[5m])) by (error_type)
/
ignoring(error_type) group_left
sum(rate(gen_ai_client_operation_duration_seconds_count[5m]))
# Débit de coût estimé (euros par seconde), via tokens et prix injectés en labels.
# Diviser par le débit de requêtes pour obtenir un coût par requête.
# price_in et price_out sont fournis par un recording rule de prix ou un relabel.
- record: genai:cost_rate:eur_per_second
expr: |
(sum(rate(gen_ai_client_token_usage_sum{gen_ai_token_type="input"}[5m])) by (gen_ai_request_model) * on(gen_ai_request_model) group_left price_in_eur_per_token)
+
(sum(rate(gen_ai_client_token_usage_sum{gen_ai_token_type="output"}[5m])) by (gen_ai_request_model) * on(gen_ai_request_model) group_left price_out_eur_per_token)
# Tokens entrée moyens par requête (détection du gonflement de prompt).
- record: genai:input_tokens_per_request:avg
expr: |
sum(rate(gen_ai_client_token_usage_sum{gen_ai_token_type="input"}[1h])) by (gen_ai_request_model)
/
sum(rate(gen_ai_client_operation_duration_seconds_count[1h])) by (gen_ai_request_model)

La règle de coût multiplie des jetons par un prix. Ce prix ne tombe pas du ciel : on le range dans une petite série par modèle, comme une étiquette de prix posée sur chaque rayon, tenue à jour à partir de votre table de prix datée (annexe D). Les prix changent vite et varient selon les contrats. Ce guide n’en donne donc aucun ; utilisez la grille datée de votre fournisseur et remplacez <p_in> et <p_out> par vos prix en euros par token.

# <p_in> et <p_out> : à renseigner depuis la grille datée de votre fournisseur.
- record: price_in_eur_per_token
labels: { gen_ai_request_model: "demo-llm" }
expr: vector(<p_in>)
- record: price_out_eur_per_token
labels: { gen_ai_request_model: "demo-llm" }
expr: vector(<p_out>)

La jointure group_left de la règle de coût lit ces séries. Tant qu’aucune série de prix n’existe pour un modèle, la jointure ne renvoie rien et la règle n’émet pas de coût pour ce modèle ; les règles en jetons (genai:input_tokens_per_request:avg) restent disponibles. En production, un job relit une table de prix versionnée pour produire ces deux séries. Le lab public genaiotel suit une variante : il calcule le coût de chaque span dans le Collector (avec OTTL, son langage de transformation) à partir d’une table de prix, puis une règle vmalert en tire la série de coût.

Je recommande un tableau de bord Grafana par couche, reliés entre eux par le trace_id. Les panneaux principaux montrent la latence p95, le taux d’erreur par error.type, la répartition des finish_reasons, le coût par requête et par fonctionnalité et l’évolution des jetons d’entrée par requête.

La règle de conception est simple : chaque panneau doit éclairer une décision, sinon on le supprime. Un panneau qui représente un SLO a son alerte (voir le guide, 9.5).

Vérifiez que les appels à vos modèles passent par le même Collector que le reste de vos services. Si ce n’est pas le cas, c’est le premier chantier, avant tout nouvel outil. Ensuite, posez la règle des jetons d’entrée par requête : elle ne demande aucun prix et révèle très tôt un prompt qui gonfle.


Révisé le 2 octobre 2026 : prix retirés, noms de métriques corrigés (suffixe _seconds ajouté par l’exportateur), règle TTFT ajoutée, filtre de contenu déplacé dans le pipeline de traces, renvoi au lab public genaiotel, mention du rachat de Langfuse par ClickHouse. Les métriques de jetons évoluent dans le dépôt semantic-conventions-genai (voir la partie I).

Révisé le 4 octobre 2026 : la règle de conception des tableaux de bord renvoie au guide, 9.5, le piège correspondant ayant quitté la partie VIII.

Révisé le 25 octobre 2026 : page réécrite pour un public plus large (scénario d’ouverture, termes expliqués, configurations repliées), sans changement de fond.