Spans, traces et contexte
- Leçon 4
- 40 min
- Module 2 : OpenTelemetry pour les agents
Où nous en sommes
Dans le module 1, nous avons lu les traces déjà présentes dans le projet. Une ligne de journal verte cachait un remboursement payé deux fois. Mais nous n'avons pas demandé comment construire une trace, ni comment garder ensemble les étapes d'une exécution. Dans cette leçon, nous découvrons le span, la trace et le contexte qui les relie. Nous faisons aussi enregistrer son premier span à notre flux de travail. Commençons dans une cuisine de restaurant.
Leçon 4 sur 28 · Observabilité des agents d'IA : traces, coûts et pistes d'auditSpans, traces et contexte
1. Pourquoi les agents ont besoin de leur propre observabilité
2. OpenTelemetry pour les agents
3. Instrumenter le flux de travail
4. Trouver les défaillances des agents dans Grafana
5. Le coût
6. Pistes d'audit
7. Alertes, niveaux de service et qualité
8. Outils : Langfuse, les autres et l'inspecteur d'exécutions
Ce que vous saurez faire
Le journal d’Amira indique que le double remboursement a été « résolu », sans rien dire des étapes de l’exécution. Faites enregistrer à chaque étape son début, sa fin et son parent. Chaque exécution devient ainsi un arbre que vous pouvez lire.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Le flux de travail en production et
python -m obs, présentés dans Découvrir le flux de travail en production. - Le double remboursement R-1014-040, présenté dans Un remboursement que personne ne peut expliquer.
- Les fonctions Python et les blocs
with. Connaître les fils d’exécution aide, mais vous n’avez pas besoin d’en avoir utilisé.
Ce qu’il vous faut sur votre ordinateur
- Votre projet
observable-workflowà l’instantanéend-of-m01(76 tests réussissent), avec son environnement virtuel actif. - Le dépôt des laboratoires à côté, comme dans le module 1 :
../nextia-learning-labs/C31/.
Testé sur macOS (Apple silicon) avec Python 3.12.13. Les commandes Windows et Linux sont écrites, mais n’ont pas été exécutées.
Une cuisine et ses bons de commande
Section intitulée « Une cuisine et ses bons de commande »Un restaurant reçoit la commande 42 : une soupe et un poisson pour une table. Le chef écrit la commande sur un bon et note l’heure. Ensuite, le travail se répartit. Un cuisinier prépare la soupe, un autre coupe le poisson et un troisième prépare la sauce. Chaque cuisinier remplit une petite fiche : la tâche, l’heure de début, l’heure de fin et « pour la commande 42 ». La fiche de la sauce indique aussi « fait partie du poisson ».
À la fin de la soirée, la gérante peut disposer les fiches devant elle. Elle voit quelle tâche a attendu, laquelle a duré le plus longtemps et quelles tâches appartenaient à chaque plat. Un seul numéro, 42, garde les fiches d’une commande ensemble. La mention « fait partie de » les organise : la commande, les plats, les tâches de chaque plat.
Quand le poisson passe au poste de grillade de l’autre côté de la cuisine, le bon l’accompagne. Sans le bon, la fiche du cuisinier à la grillade n’aurait aucun numéro de commande. Personne ne pourrait la relier aux autres.
Le problème : une ligne verte pour toute une exécution
Section intitulée « Le problème : une ligne verte pour toute une exécution »Dans le module 1, le journal d’Amira contenait une ligne par billet fermé. Voici la ligne du double remboursement :
2026-10-15T09:17:22-04:00 INFO ticket=T-90104 run=R-1014-040 model=chat-strong status=resolved writes=1 reply=sentL’application écrit cette ligne une seule fois, à la fin. Elle indique que l’exécution s’est bien terminée. Elle ne peut pas décrire ce qui s’est passé à l’intérieur. Combien d’appels de modèle? Quel outil? Qu’est-ce qui a attendu? Quel appel a payé le client une deuxième fois? La ligne indique même writes=1, car l’application a compté une seule opération.
Tomás propose une solution rapide : « Affichez la durée de chaque étape. » Mais une ligne affichée n’a aucun lien avec son exécution. Environ 45 exécutions par jour, parfois simultanées, produisent 45 flux de lignes mélangés. Une ligne request_refund 10.0 s n’indique pas à quel billet, à quelle approbation ou à quelle nouvelle tentative elle appartient.
Il nous faut ce que la cuisine possède : une fiche par étape, le numéro d’exécution sur chaque fiche et une mention « fait partie de ».
L’idée : spans, traces et contexte
Section intitulée « L’idée : spans, traces et contexte »OpenTelemetry, la norme ouverte utilisée dans ce cours, donne un nom à ces fiches.
Un span est une étape chronométrée. Il possède un nom, une heure de début, une heure de fin et des attributs. Ce sont des valeurs nommées, comme l’identifiant du billet ou le modèle. Il possède un état : non défini, ou ERROR (erreur) si l’étape a échoué. Il possède son propre identifiant de span. Il possède aussi l’identifiant de son span parent, l’étape qui l’a démarré. C’est la mention « fait partie du poisson ».
Une trace regroupe tous les spans d’une exécution. Ils partagent un identifiant de trace, le numéro de commande. Le premier span n’a aucun parent : c’est le span racine. Chaque autre span nomme son parent, ce qui forme un arbre.
Le contexte est le bon qui accompagne le travail. Dans le code, c’est « le span en cours d’exécution ». Quand un nouveau span démarre, OpenTelemetry lit le contexte et fait du nouveau span un enfant du span courant. Une fonction n’a donc pas besoin d’un paramètre pour son parent : le contexte le lui fournit.
Deux dessins montrent la même trace. Un arbre montre qui a démarré qui. Une cascade place chaque span sur une ligne du temps, une rangée par span, les enfants sous leur parent. La cascade permet de lire l’ordre et le temps d’attente.
Ajouter le code du module
Section intitulée « Ajouter le code du module »L’instantané end-of-m02 contient le code de ce module. Copiez maintenant les fichiers des spans et des noms pour pouvoir aussi exécuter le petit exemple ci-dessous. La dernière leçon du module copie les fichiers du Collector.
-
Dans le terminal, ouvrez le dossier de votre projet, avec l’environnement virtuel actif. Vérifiez que les tests réussissent :
python -m pytest -q. La dernière ligne indique76 passed, 1 deselected(76 tests réussis, 1 désélectionné). -
Copiez les fichiers nouveaux et modifiés depuis l’instantané :
Fenêtre de terminal S=../nextia-learning-labs/C31/snapshots/end-of-m02cp $S/resolver/telemetry.py $S/resolver/conventions.py $S/resolver/observe.py resolver/cp $S/resolver/runner.py $S/resolver/live.py $S/resolver/__main__.py resolver/cp $S/obs/redaction.py $S/obs/__main__.py obs/cp $S/tests/conftest.py $S/tests/test_telemetry.py tests/cp $S/requirements.txt $S/.env.example .Fenêtre de terminal $S = "..\nextia-learning-labs\C31\snapshots\end-of-m02"Copy-Item $S\resolver\telemetry.py, $S\resolver\conventions.py, $S\resolver\observe.py resolver\Copy-Item -Force $S\resolver\runner.py, $S\resolver\live.py, $S\resolver\__main__.py resolver\Copy-Item -Force $S\obs\redaction.py, $S\obs\__main__.py obs\Copy-Item -Force $S\tests\conftest.py, $S\tests\test_telemetry.py tests\Copy-Item -Force $S\requirements.txt, $S\.env.example .Fenêtre de terminal S=../nextia-learning-labs/C31/snapshots/end-of-m02cp $S/resolver/telemetry.py $S/resolver/conventions.py $S/resolver/observe.py resolver/cp $S/resolver/runner.py $S/resolver/live.py $S/resolver/__main__.py resolver/cp $S/obs/redaction.py $S/obs/__main__.py obs/cp $S/tests/conftest.py $S/tests/test_telemetry.py tests/cp $S/requirements.txt $S/.env.example . -
Installez les trois nouveaux paquets : l’API d’OpenTelemetry, son SDK et un exportateur qui envoie la télémétrie par HTTP.
Fenêtre de terminal python -m pip install -r requirements.txtpython -m pip show opentelemetry-sdkLa deuxième commande affiche
Version: 1.45.1(version : 1.45.1) sur sa deuxième ligne. -
Exécutez les tests :
python -m pytest -q. La dernière ligne indique maintenant79 passed, 1 deselected(79 tests réussis, 1 désélectionné). Les trois nouveaux tests se trouvent danstests/test_telemetry.py. Ils vérifient qu’une exécution forme une trace, qu’aucun texte ne quitte l’application et que les métriques portent les exécutions.
Qu’avez-vous copié? resolver/telemetry.py configure OpenTelemetry à un seul endroit : les fournisseurs qui créent les spans, les métriques et les événements, et leur destination. Par défaut, ils vont dans des fichiers sous work/telemetry/. Les fichiers utilisent le format OTLP JSON. OTLP est le protocole d’OpenTelemetry pour envoyer la télémétrie, et le Collector écrit le même format. Les événements utilisent l’API de journaux d’OpenTelemetry, que Python nomme encore opentelemetry._logs, avec un trait de soulignement. Elle n’est pas encore stable dans le SDK Python, donc ses noms peuvent changer. resolver/observe.py crée le span d’exécution, et resolver/runner.py l’ouvre autour de chaque exécution. resolver/conventions.py contient les noms, le sujet de la prochaine leçon.
Un petit exemple : une trace à la main
Section intitulée « Un petit exemple : une trace à la main »Avant de modifier le flux de travail, construisez une trace à la main. Ce script comporte cinq étapes : un billet, une recherche de commande, une réponse, la même réponse depuis un fil d’exécution et un message vers un autre service. Il garde les spans terminés en mémoire et les affiche. Enregistrez le code ci-dessous dans work/tiny_trace.py, dans votre projet. Le dossier work/ ne fait pas partie du code du projet : supprimez-le pour recommencer.
import threading
from opentelemetry import context, propagate, tracefrom opentelemetry.sdk.trace import TracerProviderfrom opentelemetry.sdk.trace.export import SimpleSpanProcessorfrom opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
saved = InMemorySpanExporter()provider = TracerProvider()provider.add_span_processor(SimpleSpanProcessor(saved))tracer = provider.get_tracer("tiny")
def look_up_order(): with tracer.start_as_current_span("look up the order"): pass
def write_reply(): with tracer.start_as_current_span("write the reply"): pass
def write_reply_in(ctx): token = context.attach(ctx) # the thread takes the parent's context first try: write_reply() finally: context.detach(token)
# 1. Functions: the current span travels with the call.with tracer.start_as_current_span("handle ticket"): look_up_order() write_reply()
# 2. A thread: it starts with an empty context, unless we give it ours. t = threading.Thread(target=write_reply) t.start() t.join() t = threading.Thread(target=write_reply_in, args=(context.get_current(),)) t.start() t.join()
# 3. Another service: the context goes into the message as a traceparent header. message = {} propagate.inject(message) print("message:", message)
# The other service reads the header and continues the same trace.with tracer.start_as_current_span("send the reply", context=propagate.extract(message)): pass
names = {s.context.span_id: s.name for s in saved.get_finished_spans()}for s in saved.get_finished_spans(): parent = names.get(s.parent.span_id, "?") if s.parent else "-" print(f"trace {s.context.trace_id:032x}"[:14], f"span {s.context.span_id:016x}"[:13], f"{s.name:<18} parent: {parent}")Exécutez-le avec python work/tiny_trace.py. L’exécution du cours a affiché :
message: {'traceparent': '00-ccd4d26ed047112cc342d874fa714b7e-699b79a1aa4f0839-03'}trace ccd4d26e span d8717ea7 look up the order parent: handle tickettrace ccd4d26e span 48a37482 write the reply parent: handle tickettrace 2995737c span 361b4d39 write the reply parent: -trace ccd4d26e span aca0c364 write the reply parent: handle tickettrace ccd4d26e span 699b79a1 handle ticket parent: -trace ccd4d26e span 469b4b4e send the reply parent: handle ticketVos identifiants seront différents : ils sont aléatoires. Lisez la sortie ligne par ligne :
- Les spans s’affichent dans leur ordre de fin.
handle ticket(traiter le billet) est cinquième, car il se termine après ses enfants. Un parent dure toujours au moins aussi longtemps que ses enfants. - Les fonctions.
look up the order(chercher la commande) et le premierwrite the reply(rédiger la réponse) ont le parenthandle ticketet la traceccd4d26e. Personne ne leur a passé le parent : le contexte l’a fait. - Le premier fil d’exécution. Son span possède une nouvelle trace,
2995737c, et aucun parent. Un nouveau fil d’exécution démarre avec un contexte vide. Son span est donc devenu la racine d’une deuxième trace. L’exécution est fragmentée : ses étapes se trouvent maintenant dans deux traces. - Le deuxième fil d’exécution. Il attache d’abord le contexte du parent (
write_reply_inappellecontext.attach), donc son span rejoint la trace. - Un autre service.
propagate.injecta écrit le contexte dans le message sous forme de traceparent. C’est un court texte au format W3C Trace Context. Il contient la version00, l’identifiant de trace, l’identifiant du span parent et les indicateurs. Le parent ici est699b79a1…, l’identifiant dehandle ticket.01signifie « échantillonné ». Ce SDK active aussi l’indicateur « identifiant de trace aléatoire », donc vous voyez03. Le destinataire lit l’en-tête avecpropagate.extractet poursuit la même trace.
Description textuelle du diagramme
Les mêmes cinq spans que dans la sortie du script. Dans un même fil d’exécution, le contexte suit chaque appel de fonction, donc les enfants trouvent leur parent. Un nouveau fil d’exécution démarre avec un contexte vide. Sans context.attach, son span démarre une deuxième trace sans parent. Entre services, le contexte voyage dans le message sous forme d’en-tête traceparent, et le destinataire poursuit la même trace.
Le contexte traverse donc les fonctions tout seul. Il traverse les fils d’exécution et les services seulement quand le code le transporte. Le module 3 le transporte entre les deux processus du flux de travail et à travers un appel MCP.
Une exécution du flux de travail sous forme d’arbre
Section intitulée « Une exécution du flux de travail sous forme d’arbre »Regardez maintenant une vraie exécution. Dans la semaine enregistrée, le double remboursement R-1014-040 possède deux traces. Sa première trace représente le travail de l’agent, du billet à la proposition :
python -m obs trace R-1014-040 --data data/telemetry/weekTrace 1 f0433c4403e2767e1d69ece18a947526 Wed 14 Oct 17:52:00 6.6 s 0.0 s |========================| 6.56 s invoke_agent support-resolver resolve rule W2 0.0 s |========= | 2.39 s chat chat-strong 2160 in / 47 out US$0.00479 stop 2.4 s | = | 0.00 s execute_tool get_order ok LK-793996 2.4 s | ================| 4.17 s chat chat-strong 2426 in / 218 out US$0.00703 stop 6.6 s | =| 0.00 s approval.request needs agentLa sortie continue avec la deuxième trace. Nous lirons cette deuxième trace et les 15 heures d’attente entre les deux dans le module 3.
Description textuelle du diagramme
L’arbre montre une racine, invoke_agent support-resolver, avec quatre enfants : deux appels de modèle, une recherche de commande et la demande d’approbation. La cascade place les mêmes spans sur une ligne du temps. Le premier appel de modèle prend 2.39 s et demande la commande. La recherche est instantanée. Le deuxième appel prend 4.17 s et propose le remboursement. Ensuite, l’exécution demande l’intervention d’une personne. Presque toutes les 6.56 s correspondent au temps du modèle.
Lisez la cascade comme la gérante de la cuisine lit ses fiches. Le span racine dure aussi longtemps que l’exécution entière. Chaque enfant se trouve à l’intérieur sur la ligne du temps. L’arbre ne dit rien du temps, et la cascade ne cache rien de l’ordre : il vous faut les deux.
Les spans de modèle de la semaine enregistrée durent aussi longtemps que les appels enregistrés. Une relecture répond en microsecondes, mais un span de 0,1 ms n’enseignerait rien. Le projet garde donc une horloge d’exécution. C’est une ligne du temps par exécution qui avance selon la latence enregistrée de chaque appel rejoué. Gardez cela en tête pour la prochaine section.
Exercice guidé : votre premier span
Section intitulée « Exercice guidé : votre premier span »-
Exécutez un billet :
Fenêtre de terminal python -m resolver run T-80008La dernière ligne est
Reply sent. Ticket: resolved.(réponse envoyée, billet résolu), comme dans le module 1. Le flux de travail n’a pas changé ce qu’il fait. -
Lisez sa trace :
Fenêtre de terminal python -m obs trace T-80008Run T-80008-agent-chat-small-1 | ticket T-80008 | chat-small (agent) | release 2.0.0 | language en0 model call(s), 0 read(s), 0 write call(s), 0 tokens in, 0 out, US$0.00000Trace 1 a9f8cfdc1f12fd4cb4a36f4ee661b5c9 … 0.0 s0.0 s | | 0.00 s invoke_agent support-resolver reply_only rule W1Outcome: resolvedUne trace, un span : la racine. Votre identifiant de trace et votre durée diffèrent.
-
Ouvrez le span brut. Le fichier
work/telemetry/traces.jsonlcontient une requête d’exportation par ligne. Affichez-le sous une forme lisible :Fenêtre de terminal python -m json.tool work/telemetry/traces.jsonl | lessFenêtre de terminal python -m json.tool work\telemetry\traces.jsonl | moreFenêtre de terminal python -m json.tool work/telemetry/traces.jsonl | lessAppuyez sur
qpour quitterless. Le span lui-même commence ainsi (extrait abrégé) :{"traceId": "a9f8cfdc1f12fd4cb4a36f4ee661b5c9","spanId": "0c1c066ee1b6f4e3","name": "invoke_agent support-resolver","kind": "SPAN_KIND_INTERNAL","startTimeUnixNano": "…","endTimeUnixNano": "…","attributes": [{"key": "gen_ai.operation.name", "value": {"stringValue": "invoke_agent"}},{"key": "gen_ai.request.model", "value": {"stringValue": "chat-small"}},{"key": "larkfield.ticket.id", "value": {"stringValue": "T-80008"}},{"key": "larkfield.proposal.outcome", "value": {"stringValue": "reply_only"}},{"key": "gen_ai.usage.input_tokens", "value": {"intValue": "4580"}},{"key": "larkfield.outcome", "value": {"stringValue": "resolved"}}],"status": {}}Le span possède un identifiant de trace et un identifiant de span, mais aucun
parentSpanId: c’est une racine. Son état est vide : non défini, donc aucune erreur. Les heures de début et de fin sont égales.
Pourquoi le span dure-t-il 0,00 s? L’horloge d’exécution avance seulement quand un span de modèle ajoute une latence enregistrée. Il n’y a pas encore de spans de modèle. Le temps du modèle n’entre dans la trace qu’au module 3, quand nous ajoutons les spans de modèle. La ligne de résumé d’obs indique 0 model call(s) (0 appel de modèle) pour la même raison. Mais le span racine possède déjà les totaux de l’exécution comme attributs : 4 580 jetons en entrée, la proposition et le résultat.
Regardez encore une chose. live.close() ajoute le résultat au span sans le recevoir comme paramètre. Il demande le span courant : trace.get_current_span(). C’est le contexte à l’œuvre dans le flux de travail.
Quand ajouter un span, et ce qu’il coûte
Section intitulée « Quand ajouter un span, et ce qu’il coûte »Sam demande : « Faut-il un span pour chaque fonction? »
Non. Un span mérite d’être ajouté quand il répond à une question que vous poserez. Où le temps est-il passé? Quelle étape a échoué? Quel appel a écrit? Dans ce cours, ces étapes sont l’exécution, chaque appel de modèle, chaque appel d’outil, chaque écriture et chaque approbation. Un span autour d’une fonction utilitaire qui formate une date rend seulement l’arbre plus difficile à lire.
Un span a aussi un coût. L’équipe du cours a mesuré le code du flux de travail sur 350 exécutions rejouées. La durée médiane était de 0,53 ms sans télémétrie et de 2,42 ms avec exportation vers des fichiers. C’est environ 1,9 ms de plus. Chaque exécution produisait environ 4,3 spans et 9,3 Ko de données de trace. Par rapport aux secondes du modèle, 1,9 ms est peu. Mais le stockage augmente avec chaque exécution, et quelqu’un doit garder les noms stables. La leçon Ce qu’il faut enregistrer, et ce qu’il ne faut pas du module 1 détermine ce qui mérite ce coût.
Erreur courante
Une étape apparaît comme une deuxième trace
Symptôme : une étape appartenant à une exécution apparaît comme une trace distincte, sans parent. Dans le petit exemple, c’est la ligne trace 2995737c … write the reply parent: -.
Cause : l’étape s’est exécutée dans un nouveau fil d’exécution ou dans un autre processus, sans emporter le contexte. Un nouveau fil d’exécution démarre avec un contexte vide, donc son premier span devient une racine.
Diagnostic : comparez les identifiants de trace. Tous les spans d’une exécution doivent avoir le même identifiant de trace. Un span dont le parent est -, mais qui n’est pas la première étape de l’exécution, est orphelin.
Correction : transportez le contexte. Dans un fil d’exécution, attachez le contexte du parent avant de démarrer le span (write_reply_in appelle context.attach). C’est ce que fait le deuxième fil d’exécution de l’exemple. Entre processus ou services, injectez un traceparent dans le message et extrayez-le de l’autre côté.
Erreur courante
obs : aucune télémétrie dans work/telemetry
Symptôme : après python -m resolver run T-80008, python -m obs trace T-80008 affiche :
No telemetry in …/work/telemetry. Run a ticket first (python -m resolver run T-80008), or read the replayed week: --data data/telemetry/weekCause : la variable OBS_EXPORT vaut off (désactivé) dans votre interpréteur de commandes, donc le flux de travail n’a rien enregistré. Ou vous avez copié les fichiers sans installer requirements.txt. L’exécution a alors échoué avec ModuleNotFoundError: No module named 'opentelemetry' (aucun module nommé « opentelemetry »).
Correction : supprimez la variable (unset OBS_EXPORT, ou dans PowerShell Remove-Item Env:OBS_EXPORT), installez les dépendances et exécutez le billet de nouveau.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Tomás dit : « Chaque span a l'identifiant de trace. Nous n'avons donc pas besoin de l'identifiant du span parent. » À partir de la première trace de R-1014-040, expliquez ce que vous perdriez sans le parent.
Afficher la réponse
L’identifiant de trace indique quels spans appartiennent à l’exécution, mais pas comment ils s’articulent. Sans l’identifiant du span parent, vous auriez cinq spans de la trace f0433c44, sans arbre. Vous ne pourriez pas dire que les deux appels de modèle et la recherche de commande étaient des étapes de l’agent, invoke_agent support-resolver. Dans une exécution avec deux processus, vous ne pourriez pas dire quel processus a fait quel appel. Le parent forme l’arbre; les temps forment la vue en cascade.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Faites une prédiction : dans le petit exemple, le span du premier fil d'exécution n'avait pas de parent. Que changerait-il si le fil appelait look_up_order() au lieu de write_reply()? Et si le code attachait d'abord le contexte?
Afficher la réponse
Rien ne change dans le premier cas. Tout span qui démarre dans un nouveau fil sans le contexte du parent devient la racine d’une nouvelle trace. C’est vrai quelle que soit la fonction. Le span « look up the order » (chercher la commande) aurait son propre identifiant de trace et le parent « - ». Avec le contexte attaché d’abord, comme dans write_reply_in, le span rejoint la trace de l’exécution. Son parent est « handle ticket » (traiter le billet), comme pour le span aca0c364 dans la sortie.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Un span est une étape chronométrée : nom, début, fin, attributs, état, son propre identifiant et celui de son parent.
- Une trace est l’arbre des spans d’une exécution, reliés par un même identifiant de trace; le span racine n’a pas de parent.
- Le contexte est le span courant. Il suit les appels de fonction automatiquement; les fils d’exécution et les services doivent le transmettre. Sinon, l’exécution se divise en deux traces. Entre les services, il circule sous forme de
traceparent. - Un arbre montre qui a démarré quoi; une vue en cascade montre quand. Première trace de R-1014-040 : 6,56 s, presque entièrement consacrées au modèle.
- Votre flux de travail enregistre maintenant un span par exécution. Il dure 0,00 s sur l’horloge de l’exécution, jusqu’à l’arrivée des spans du modèle.
Vous pouvez maintenant représenter une exécution par une trace et la lire comme un arbre et une vue en cascade. Mais les attributs de notre span portent des noms comme gen_ai.request.model et larkfield.ticket.id. Qui les a choisis, et pourquoi un outil les comprendrait-il? Ensuite, vous découvrirez les noms qu’OpenTelemetry a convenus pour les exécutions d’agents, les appels de modèle et les appels d’outils. Vous ajouterez aussi votre propre span.
Leçon suivante : Les conventions GenAI pour les exécutions d'agents