L’observabilité IA consiste à comprendre non seulement si une application d’intelligence artificielle répond, mais si elle répond juste, à quel coût et en empruntant quel chemin. Dynatrace a finalisé le rachat d’Arize, l’éditeur de la plateforme Arize AX et du projet open source Phoenix : c’est l’occasion de poser à plat ce que recouvre vraiment ce sujet, du premier prototype jusqu’à l’exploitation à grande échelle.
Jusqu’ici, deux mondes cohabitaient sans vraiment se parler. D’un côté, les ingénieurs IA tracent leurs agents, lancent des évaluations et comparent des expériences dans des outils pensés pour eux. De l’autre, les équipes SRE et plateforme surveillent services, infrastructure et expérience utilisateur. Entre les deux, les équipes métier constatent les effets, bons ou mauvais, sans voir les causes.
Cet article sert de point d’entrée à notre série sur l’observabilité de l’IA. Il décrit le cycle de vie complet, propose une méthode concrète pour le mettre en place et renvoie vers des articles plus ciblés pour chaque étape.
Pourquoi l’observabilité IA ne se résume pas au monitoring applicatif
Prenons un assistant de support client branché sur une base documentaire. Un matin, il annonce à des dizaines de clients un délai de remboursement de 30 jours alors que la politique est passée à 14 jours la semaine précédente. Aucune erreur HTTP, une latence normale, un taux de disponibilité parfait. Côté monitoring classique, tout est vert. Pourtant le service est en panne du point de vue de l’entreprise.
C’est la particularité des systèmes d’IA : ils peuvent échouer en silence, avec une réponse plausible et assurée. Un agent peut aussi terminer sa tâche en prenant un détour coûteux, en appelant cinq fois le même outil ou en lisant un document périmé. Pour diagnostiquer ces cas, il faut des signaux que la télémétrie applicative ne fournit pas seule : la trajectoire de l’agent, le contexte récupéré, les outils appelés, les tokens consommés et une mesure de la qualité de la réponse.
Inversement, la télémétrie d’IA seule ne suffit pas non plus. Une réponse lente peut venir d’une base vectorielle saturée, d’un nœud GPU en difficulté ou d’un appel réseau vers un fournisseur de modèles. L’observabilité IA utile relie les deux niveaux.
Ce que change le rachat d’Arize par Dynatrace
Arize s’adresse aux ingénieurs IA : traçage des applications et des agents, évaluations, jeux de données, expérimentations. Dynatrace s’adresse aux équipes qui exploitent l’environnement numérique dans son ensemble. L’objectif affiché est de relier ces deux disciplines pour couvrir tout le cycle de vie de l’IA.
Quelques points factuels méritent d’être retenus :
- Arize AX et la plateforme Dynatrace restent proposés séparément, et Phoenix reste un projet open source.
- Phoenix s’appuie sur OpenTelemetry et sur OpenInference, les conventions d’instrumentation créées par Arize pour l’IA.
- Dynatrace a indiqué vouloir soutenir Phoenix et contribuer à la gouvernance d’OpenInference ; pour les rapprochements en cours avec les conventions GenAI d’OpenTelemetry, suivez les dépôts officiels des deux projets.
- La feuille de route d’intégration n’est pas encore publiée : Dynatrace indique qu’elle sera précisée au fil des mois.
Pour une équipe qui démarre, la conséquence pratique est simple : miser sur des standards ouverts (OpenTelemetry, conventions GenAI) reste le choix le moins risqué, quel que soit l’outil final. Nous comparons d’ailleurs les options open source dans notre article sur Langfuse et OpenLLMetry.
Les quatre temps de l’observabilité IA, du prototype à la production
Prototype : voir ce que fait l’agent
Dès les premiers essais, tracer chaque appel de modèle, chaque récupération de documents et chaque outil appelé. Ces traces servent à déboguer, mais surtout à constituer les premiers exemples d’évaluation.
Pré-production : évaluer avant de livrer
Un jeu de questions de référence, des évaluateurs (règles, comparaison à une réponse attendue ou LLM juge) et un seuil de qualité intégré au pipeline. Un changement de prompt ou de modèle devient alors testable comme n’importe quel changement de code.
Production : traces LLM, latence et coûts
En exploitation, on suit les mêmes traces, enrichies du contexte de l’infrastructure : latence par étape, tokens par requête, coût par conversation, erreurs des fournisseurs. Les SRE y ajoutent leurs objectifs de niveau de service, comme nous le détaillons dans ce que les charges IA changent pour les SRE.
Amélioration continue : détecter la dérive
Un système d’IA ne reste jamais figé : nouveau modèle, prompt modifié, documents ajoutés, outil remplacé. La dérive se détecte en évaluant en continu un échantillon du trafic réel. Chaque incident doit produire un nouvel exemple dans le jeu de régression.
En pratique : bâtir une boucle d’observabilité IA
Étape 1 — Cartographier les usages
Listez les applications et agents en production ou en cours de développement, avec pour chacun : le modèle utilisé, les sources de données, les outils autorisés, le processus métier servi et l’équipe responsable. Sans cet inventaire, impossible de savoir quoi instrumenter en priorité.
Étape 2 — Instrumenter avec OpenTelemetry
Ajoutez un span par appel de modèle avec les attributs des conventions sémantiques GenAI. L’exemple ci-dessous est volontairement simplifié ; client_llm représente votre propre client.
from opentelemetry import trace
tracer = trace.get_tracer("assistant-support")
def repondre(question, documents):
with tracer.start_as_current_span("chat assistant-support") as span:
span.set_attribute("gen_ai.operation.name", "chat")
span.set_attribute("gen_ai.request.model", MODELE)
span.set_attribute("app.rag.nb_documents", len(documents))
reponse = client_llm.generer(question, documents)
span.set_attribute("gen_ai.usage.input_tokens", reponse.tokens_entree)
span.set_attribute("gen_ai.usage.output_tokens", reponse.tokens_sortie)
return reponse.texte
Les noms d’attributs GenAI évoluent encore : vérifiez la version des conventions supportée par vos bibliothèques. Pour suivre une requête de l’interface jusqu’à l’hôte, voyez aussi OpenTelemetry de bout en bout avec Dynatrace.
Étape 3 — Définir des évaluateurs
Commencez petit : trois à cinq critères mesurables. Par exemple, pour l’assistant de support :
evaluateurs:
- nom: reponse_fondee # la réponse cite-t-elle un document récupéré ?
type: llm_juge
- nom: politique_a_jour # le document cité a-t-il moins de 30 jours ?
type: regle
- nom: longueur_raisonnable
type: regle
max_tokens_sortie: 400
seuil_publication: 0.90
Étape 4 — Relier aux signaux SRE et métier
Associez chaque trace IA à son service, à son hôte ou pod et à l’événement métier concerné (ticket résolu, dossier traité). C’est ce lien qui permet de dire si une baisse de qualité vient du modèle, de l’infrastructure ou des données. La mesure côté métier est développée dans mesurer le ROI de l’IA.
Étape 5 — Réinjecter les enseignements
Chaque réponse mal notée en production rejoint le jeu de régression. Chaque incident donne lieu à un nouvel évaluateur ou à un test. La boucle se referme : la production nourrit le développement.
Bonnes pratiques
- Instrumenter dès le prototype plutôt qu’à la veille de la mise en production.
- Suivre le coût par tâche réussie, pas seulement le coût total en tokens.
- Masquer ou exclure les données personnelles des prompts et réponses tracés.
- Évaluer en continu un échantillon du trafic réel, pas uniquement avant chaque version.
- Versionner prompts, modèles et jeux d’évaluation comme du code.
- Garder l’humain dans la boucle pour les actions d’agent à fort impact, un point repris dans l’IA et la fiabilité au quotidien.
Les équipes plateforme ont un rôle clé pour diffuser ces pratiques par défaut, comme le montre notre panorama du platform engineering en 2026.
Questions fréquentes
Quelle différence entre observabilité IA et monitoring de modèle ?
Le monitoring de modèle surveille surtout des métriques du modèle lui-même. L’observabilité IA couvre toute la chaîne : traces d’agent, contexte, outils, infrastructure, coûts et effets métier, avec la possibilité d’enquêter sur un cas précis.
Phoenix reste-t-il open source après le rachat ?
Oui, selon l’annonce de Dynatrace, Phoenix reste disponible en open source et Arize AX reste proposé comme offre distincte. Consultez le dépôt officiel pour l’état à jour du projet.
Faut-il attendre l’intégration Arize–Dynatrace pour commencer ?
Non. Instrumenter avec OpenTelemetry et les conventions GenAI, construire un jeu d’évaluation et relier les traces aux services sont des étapes utiles dès maintenant, quel que soit l’outil retenu.
Conclusion
L’observabilité IA n’est pas un tableau de bord de plus : c’est une boucle qui relie la construction, l’exploitation et la valeur métier d’un système d’IA. Le rapprochement de Dynatrace et d’Arize illustre cette convergence, mais la méthode est accessible dès aujourd’hui : tracer, évaluer, relier, réinjecter. Pour approfondir les fondations ouvertes, consultez le dépôt GitHub de Phoenix.
Pour aller plus loin : Dynatrace completes acquisition of Arize to advance full-lifecycle AI observability (blog Dynatrace, en anglais).
span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC ni aux projets cités. Les marques citées appartiennent à leurs propriétaires. Les outils évoluent vite : vérifiez les commandes et options dans leur documentation officielle.
8 comments