Aller au contenu
English

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.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité
Leçon 4 sur 28 · Observabilité des agents d'IA : traces, coûts et pistes d'auditSpans, traces et contexte
Aperçu du cours

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 mainEnviron 40 minutes

Ce que vous devez savoir

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.

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=sent

L’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 ».

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.

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.

  1. 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 indique 76 passed, 1 deselected (76 tests réussis, 1 désélectionné).

  2. Copiez les fichiers nouveaux et modifiés depuis l’instantané :

    Fenêtre de terminal
    S=../nextia-learning-labs/C31/snapshots/end-of-m02
    cp $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 .
  3. 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.txt
    python -m pip show opentelemetry-sdk

    La deuxième commande affiche Version: 1.45.1 (version : 1.45.1) sur sa deuxième ligne.

  4. Exécutez les tests : python -m pytest -q. La dernière ligne indique maintenant 79 passed, 1 deselected (79 tests réussis, 1 désélectionné). Les trois nouveaux tests se trouvent dans tests/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.

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.

work/tiny_trace.py
import threading
from opentelemetry import context, propagate, trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from 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 ticket
trace ccd4d26e span 48a37482 write the reply parent: handle ticket
trace 2995737c span 361b4d39 write the reply parent: -
trace ccd4d26e span aca0c364 write the reply parent: handle ticket
trace ccd4d26e span 699b79a1 handle ticket parent: -
trace ccd4d26e span 469b4b4e send the reply parent: handle ticket

Vos identifiants seront différents : ils sont aléatoires. Lisez la sortie ligne par ligne :

  1. 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.
  2. Les fonctions. look up the order (chercher la commande) et le premier write the reply (rédiger la réponse) ont le parent handle ticket et la trace ccd4d26e. Personne ne leur a passé le parent : le contexte l’a fait.
  3. 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.
  4. Le deuxième fil d’exécution. Il attache d’abord le contexte du parent (write_reply_in appelle context.attach), donc son span rejoint la trace.
  5. Un autre service. propagate.inject a écrit le contexte dans le message sous forme de traceparent. C’est un court texte au format W3C Trace Context. Il contient la version 00, l’identifiant de trace, l’identifiant du span parent et les indicateurs. Le parent ici est 699b79a1…, l’identifiant de handle ticket. 01 signifie « échantillonné ». Ce SDK active aussi l’indicateur « identifiant de trace aléatoire », donc vous voyez 03. Le destinataire lit l’en-tête avec propagate.extract et poursuit la même trace.
Le span racine « handle ticket » de la trace ccd4d26e possède cinq flèches. Deux flèches nommées « appel de fonction » mènent à « look up the order » et « write the reply », chacun avec le parent handle ticket. Une flèche pointillée nommée « nouveau fil d'exécution, contexte vide » mène à un cadre rouge pointillé : « write the reply », trace 2995737c, aucun parent, une deuxième trace. Une flèche nommée « nouveau fil d'exécution, contexte attaché » mène à « write the reply » avec le parent handle ticket. Une flèche nommée « message avec un traceparent » mène à « send the reply (another service) » avec le parent handle ticket.
Le contexte accompagne automatiquement un appel de fonction. Un fil d'exécution et un message vers un autre service doivent le transporter, sinon l'exécution se divise en deux traces.
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 :

Fenêtre de terminal
python -m obs trace R-1014-040 --data data/telemetry/week
Trace 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 agent

La 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.

En haut : un arbre. Le span racine invoke_agent support-resolver, 6,56 s, possède quatre enfants alignés : chat chat-strong 2,39 s, execute_tool get_order 0,00 s, chat chat-strong 4,17 s, approval.request 0,00 s. Une note : chaque span enfant nomme son span parent; le span racine n'en a aucun; les cinq partagent un identifiant de trace. En bas : une cascade sur un axe temporel de 0 à 6,6 secondes. La barre racine couvre les 6,56 s et propose de résoudre. La première barre chat va de 0 à 2,39 s, avec 2 160 jetons en entrée et 47 en sortie. La barre get_order est une fine marque à 2,39 s, lecture, succès. La deuxième barre chat va de 2,39 à 6,56 s, avec 2 426 en entrée et 218 en sortie. La marque approval.request est à 6,56 s, intervention d'un agent nécessaire.
La première trace de R-1014-040 de la semaine enregistrée, dessinée à partir de ses cinq spans enregistrés : en arbre (qui a démarré qui) et en cascade (quand chaque étape s'est exécutée).
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.

  1. Exécutez un billet :

    Fenêtre de terminal
    python -m resolver run T-80008

    La 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.

  2. Lisez sa trace :

    Fenêtre de terminal
    python -m obs trace T-80008
    Run T-80008-agent-chat-small-1 | ticket T-80008 | chat-small (agent) | release 2.0.0 | language en
    0 model call(s), 0 read(s), 0 write call(s), 0 tokens in, 0 out, US$0.00000
    Trace 1 a9f8cfdc1f12fd4cb4a36f4ee661b5c9 … 0.0 s
    0.0 s | | 0.00 s invoke_agent support-resolver reply_only rule W1
    Outcome: resolved

    Une trace, un span : la racine. Votre identifiant de trace et votre durée diffèrent.

  3. Ouvrez le span brut. Le fichier work/telemetry/traces.jsonl contient 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 | less

    Appuyez sur q pour quitter less. 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.

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/week

Cause : 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é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.

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.

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