Aller au contenu
English

Ce que voit la passerelle et ce que voit l'application

  • Leçon 11
  • 40 min
  • Module 3 : Instrumenter le flux de travail

Où nous en sommes

Dans les quatre dernières leçons, notre flux de travail a appris à enregistrer son propre récit. Mais chez Larkfield, chaque appel de modèle passe aussi par la passerelle de modèles du cours sur la gouvernance des agents. Cette passerelle conserve son propre enregistrement de chaque appel. Dans cette leçon, nous faisons passer le flux de travail par cette passerelle et comparons ce que chaque côté voit. Nous relions les deux enregistrements par l'identifiant d'agent et le contexte de trace. Nous commençons par une carte d'entreprise et un rapport de dépenses.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité
Leçon 11 sur 28 · Observabilité des agents d'IA : traces, coûts et pistes d'auditCe que voit la passerelle et ce que voit l'application
Aperçu du cours

Ce que vous saurez faire

Faites passer les appels de modèle du flux de travail par la passerelle de modèles de Larkfield. Comparez les enregistrements d’utilisation de la passerelle aux traces du flux de travail. Reliez chaque enregistrement à son span de modèle par le contexte de trace. Vérifiez que les jetons et le coût concordent. Quand le flux de travail demande seulement une capacité, enregistrez le modèle qui a réellement répondu.

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

  • Le projet dans l’état où la dernière leçon l’a laissé : 86 tests réussissent (87 avec le paquet MCP).
  • Un terminal dans observable-workflow, avec l’environnement virtuel activé.
  • Pour la partie facultative en direct : les paquets de la passerelle (requirements-gateway.txt), un deuxième terminal et les ports 8320 à 8326 libres.

Testé sur macOS (Apple silicon) avec Python 3.12.13. Les commandes Windows et Linux sont fournies, mais n’ont pas été exécutées.

Un employé paie un hôtel avec la carte de l’entreprise. Le relevé bancaire indique le paiement : la carte utilisée, l’hôtel, le montant et la date. Il indique chaque paiement, même ceux que personne n’a déclarés.

Le rapport de dépenses de l’employé contient d’autres renseignements : le voyage, le client et la personne qui a approuvé le voyage. La banque ne les voit jamais.

À la fin du mois, quelqu’un vérifie que chaque reçu correspond à une ligne du relevé. Si les deux portent le même numéro de référence, la vérification est facile et exacte. Sans ce numéro, on les associe par date et montant, et on peut confondre deux paiements semblables.

Dans Gouverner les agents d’IA : passerelles, registres et contrôles, Larkfield place une passerelle d’IA devant chaque appel de modèle. Une passerelle d’IA est un service entre les applications et les fournisseurs de modèles. Elle vérifie quel agent appelle, applique ses limites et envoie l’appel à un modèle. Elle écrit un enregistrement d’utilisation par appel. Kwame en est responsable.

Les agents demandent à la passerelle une capacité, pas un modèle. Ce nom décrit leur besoin, par exemple strong-reasoning (raisonnement avancé). La configuration de la passerelle détermine quel modèle fournit cette capacité. Kwame peut ainsi transférer une capacité vers un nouveau modèle sans modifier les applications.

Chaque appel de modèle est donc enregistré deux fois : par la passerelle et par le span chat du flux de travail. Kwame et Amira ont tenté de comparer les deux, mais ont rencontré deux problèmes :

  • Les enregistrements ne se reliaient pas. Le flux de travail du cours sur la gouvernance envoyait un traceparent avec chaque appel. Mais il était créé à partir de l’identifiant d’exécution. Il utilisait une trace inventée par exécution et un identifiant de span aléatoire par appel. Aucun span n’avait cet identifiant. Sur 135 enregistrements de la passerelle, 0 se reliait à un span de modèle par le contexte de trace.

  • L’application ne savait pas combien elle payait. Le flux de travail demandait strong-reasoning. Sa propre table de prix contient des prix pour les modèles, pas pour les capacités. Le flux de travail affichait unknown (inconnu) pour le coût :

    Outcome: resolve (rule W2) | 2 model call(s), 1 tool call(s) | 4586 tokens in, 265 out | unknown

L’idée : chaque côté voit une partie de la vérité

Section intitulée « L’idée : chaque côté voit une partie de la vérité »

La passerelle et l’application voient le même appel depuis deux endroits :

Ce que voit la passerelle Ce que voit l’application
Qui l’agent enregistré, support-workflow, et son équipe, service l’exécution, le billet, la conception et l’étape
Quoi la capacité, le fournisseur, le déploiement et la version du modèle qui a répondu le nom du modèle demandé
Combien les jetons et le coût facturé pour chaque appel les jetons de chaque appel
Autres éléments les appels qu’elle a refusés et les appels d’applications sans aucune instrumentation les appels d’outils, les approbations, les écritures, la réponse et le résultat

Aucune des deux vues n’est complète. La passerelle ne peut pas expliquer pourquoi un appel a eu lieu, ni si l’exécution a versé deux fois un remboursement. L’application ne voit pas les appels que la passerelle a refusés avant qu’ils atteignent un modèle. Elle ne voit pas non plus une application qui n’enregistre rien.

Nous les relions donc avec trois clés :

  • Le contexte de trace. Le flux de travail envoie le vrai traceparent de son span chat avec chaque appel. La passerelle le conserve dans l’enregistrement. L’identifiant de span qu’il contient est celui du span : un enregistrement, un span.
  • L’identifiant d’exécution. Le flux de travail envoie aussi X-Run-Id. Il relie tous les appels d’une exécution, mais ne relie pas un appel précis à un span précis.
  • L’identifiant d’agent. Le agent_id de la passerelle, support-workflow, correspond au gen_ai.agent.id du flux de travail. Il relie les agents dans leur ensemble, pour le coût par agent au module 5.

La passerelle renvoie aussi des renseignements. Sa réponse contient des en-têtes : le modèle qui a répondu, son identifiant de requête et le coût facturé. resolver/gateway.py les enregistre sur le même span chat, sous larkfield.gateway.model, larkfield.gateway.request_id et larkfield.gateway.cost_usd.

Deux boîtes. À gauche, la vue de l'application, les traces du flux de travail : l'exécution avec son billet, sa conception, son résultat et sa mise en production; le span chat avec l'identifiant e41cc07e…, qui a demandé strong-reasoning; les appels d'outils, l'approbation, les écritures et la réponse. À droite, la vue de la passerelle, un enregistrement d'utilisation par appel : agent support-workflow, équipe service, capacité strong-reasoning; fournisseur azure, déploiement chat-strong, modèle gpt-6.1-sol-2026-09-29; jetons, coût, appels refusés, traceparent se terminant par -e41cc07e…-03 et identifiant d'exécution. Une flèche épaisse du span chat vers l'enregistrement : envoie traceparent et X-Run-Id. Une flèche pointillée du modèle vers le span chat : en-tête de réponse x-gateway-model, le modèle qui a répondu.
Un appel de modèle, deux enregistrements : le span chat envoie son contexte de trace à la passerelle, dont la réponse nomme le modèle. Identifiants de l'exécution de T-90104 par l'équipe du cours.
Description textuelle du diagramme

Les traces de l’application contiennent l’exécution, ses spans chat, les appels d’outils, l’approbation, les écritures et la réponse. Les enregistrements de la passerelle contiennent, pour chaque appel, l’agent et son équipe, la capacité, le fournisseur, le déploiement et la version du modèle. Ils contiennent aussi les jetons, le coût et les refus. Le span chat e41cc07e envoie son traceparent et l’identifiant d’exécution avec l’appel. L’enregistrement de cet appel dans la passerelle porte donc le même identifiant de span. L’en-tête de réponse x-gateway-model de la passerelle nomme le modèle qui a répondu, et l’application le place sur le span.

L’équipe du cours a exécuté T-90104 par la passerelle. Voici le deuxième appel de modèle, tel que chaque côté l’a enregistré :

Champ Le span chat L’enregistrement de la passerelle
Identifiant span e41cc07e075559ae dans la trace 59b819fc… traceparent 00-59b819fc8cd8d52726b79a2f93f88aeb-e41cc07e075559ae-03
Modèle a demandé strong-reasoning; larkfield.gateway.model = chat-strong (gpt-6.1-sol-2026-09-29) capacité strong-reasoning, déploiement chat-strong, version du modèle gpt-6.1-sol-2026-09-29
Jetons 2 426 en entrée, 218 en sortie tokens_in 2426, tokens_out 218
Coût larkfield.gateway.cost_usd = 0.007032 cost_usd 0.007032
Seulement ici l’étape de l’exécution, la conception, le résultat agent_id support-workflow, team service, provider azure, replica a, request_id bc2abb98aa244246

L’identifiant de span dans le traceparent de l’enregistrement est celui du span lui-même. La jointure est donc exacte : un enregistrement, un span. Le traceparent se termine par -03 : ce sont des indicateurs définis par le SDK OpenTelemetry. La jointure utilise seulement les deux identifiants.

  1. Copiez les fichiers de cette leçon : le fournisseur de passerelle, la configuration qui le connaît et la commande de jointure. Copiez aussi la version figée de l’environnement du cours sur la gouvernance, l’exécution sauvegardée par l’équipe et les notes du laboratoire.

    Fenêtre de terminal
    S=../nextia-learning-labs/C31/snapshots/end-of-m03
    cp $S/resolver/gateway.py $S/resolver/config.py resolver/
    cp $S/obs/gateway.py $S/obs/__main__.py obs/
    cp -R $S/vendor .
    cp -R $S/data/telemetry/gateway data/telemetry/
    cp $S/gateway-lab.md $S/requirements-gateway.txt $S/.env.example $S/README.md .
  2. Ouvrez resolver/gateway.py et lisez sa chaîne de documentation. Trouvez ensuite headers["traceparent"] = tp : l’appel transporte le contexte du span courant, le span chat ouvert par observed(). Trouvez c.GATEWAY_MODEL: h.get("x-gateway-model") : l’en-tête de réponse va sur le même span.

  3. Exécutez les tests : python -m pytest -q. Le nombre ne change pas : 86 tests réussis (87 avec le paquet MCP). Votre projet correspond maintenant à l’instantané end-of-m03, sauf pour votre show_spans.py.

Exercice guidé : relier l’exécution de l’équipe du cours

Section intitulée « Exercice guidé : relier l’exécution de l’équipe du cours »

L’équipe du cours a exécuté les 70 tâches du cours sur les agents par la passerelle, avec strong-reasoning. Elle a utilisé agent_structured, la conception de production du cours sur la gouvernance. Les traces sont dans data/telemetry/gateway, et les enregistrements de la passerelle dans gateway-usage.json. Cette partie ne nécessite aucune passerelle en marche.

  1. Reliez les deux :

    Fenêtre de terminal
    python -m obs gateway data/telemetry/gateway/gateway-usage.json --data data/telemetry/gateway
    Gateway records: 135 model calls (ok 134, upstream_error 1)
    Workflow traces: 70 runs, 135 model calls, 83 tool calls, 28 approval requests
    Joined by trace context (the span ID in traceparent): 135 of 135 records
    Tokens in / out: gateway 310,041 / 15,702; traces 310,041 / 15,702
    Cost: gateway US$0.77710; traces US$0.77710
    Only the gateway sees: the agent's registration and team, the capability, the provider, refused calls.
    Only the traces see: the tool calls, the approval, the outcome of the run, and which step made each call.
    capability strong-reasoning was answered by chat-strong (gpt-6.1-sol-2026-09-29)
  2. Lisez la troisième ligne : chaque enregistrement a trouvé son span. Ensuite, regardez les jetons et le coût : ils concordent exactement. Les spans sauvegardés portent un coût que le module 5 calcule à partir du modèle nommé par la passerelle. Un nom de capacité ne masque donc plus le prix.

  3. Lisez l’enregistrement qui a échoué : upstream_error (erreur en amont). Il s’agit de T-80002, dont le fournisseur a refusé l’appel enregistré avec son filtre de contenu. Lisez la trace :

    Fenêtre de terminal
    python -m obs trace T-80002 --data data/telemetry/gateway
    Run G-with-context-T-80002 | ticket T-80002 | strong-reasoning (agent_structured) | release 2.0.0 | language en
    1 model call(s), 0 read(s), 0 write call(s), 0 tokens in, 0 out, US$0.00000
    Trace 1 36d45a4fb18eddea54bf7f9e7ab72aa7 … 0.4 s
    0.0 s |========================| 0.40 s chat strong-reasoning ERROR ProviderError
    0.0 s |========================| 0.40 s invoke_agent support-resolver provider_error
    Outcome: handed_to_person | stopped: provider_error

    Le span indique seulement ProviderError (erreur du fournisseur). L’enregistrement de la passerelle explique pourquoi : statut 400, check_name provider et message du fournisseur sur sa politique de gestion du contenu. Ici, les deux vues expliquent ensemble une défaillance.

L’équipe du cours a aussi exécuté les mêmes 70 tâches avec OBS_GATEWAY_CONTEXT=off, le comportement du cours sur la gouvernance. Le flux de travail n’envoyait alors aucun vrai contexte de trace :

Mesure : l'équipe du cours a exécuté deux fois les 70 tâches par la version figée de la passerelle; réponses de modèle rejouées par le simulateur de la passerelle.
Description textuelle du graphique

Trois barres, sur 135 enregistrements de la passerelle. Avec le vrai contexte de trace : 135 reliés à leur span de modèle. Sans ce contexte : 0. Par identifiant d’exécution, dans les deux exécutions : 135. Mais l’identifiant d’exécution relie un enregistrement à une exécution de deux ou trois appels, pas à un seul span.

L’identifiant d’exécution relie les enregistrements aux exécutions. Il suffit donc pour le coût par exécution. Mais seul le contexte de trace répond à « quelle étape a fait cet appel coûteux? » Et seules les traces comptent les 83 appels d’outils et les 28 demandes d’approbation de ces exécutions : la passerelle ne les a jamais vus.

Le projet contient une version figée de l’environnement du cours sur la gouvernance dans vendor/ai-estate/. PINNED.md indique l’empreinte de chaque fichier. Sa passerelle répond avec un simulateur qui rejoue les mêmes enregistrements. Aucun compte ni aucune clé ne sont nécessaires.

  1. Installez les paquets de l’environnement : python -m pip install -r requirements-gateway.txt.

  2. Dans un deuxième terminal, dans le dossier du projet, activez l’environnement virtuel et allez dans l’environnement : cd vendor/ai-estate (PowerShell : cd vendor\ai-estate).

  3. Préparez l’environnement selon les indications de gateway-lab.md. Chaque commande affiche quelques lignes :

    Fenêtre de terminal
    python -m estate init
    python -m estate register registrations/support-workflow.yaml
    python -m estate review support-workflow --next 2026-12-01
    python -m estate credentials issue support-workflow
    python -m estate config publish --note "the registrations"

    L’enregistrement commence à l’état pending (en attente) jusqu’à son approbation après révision, comme dans le cours sur la gouvernance. Les identifiants de connexion sont dans state/credentials/; ne les copiez jamais dans le code.

  4. Démarrez-le. PYTHONPATH=../.. permet au serveur d’outils de l’environnement de trouver le code du flux de travail dans le dossier du projet :

    Fenêtre de terminal
    PYTHONPATH=../.. python -m estate up
    provsim up (process 87973) http://127.0.0.1:8320
    control up (process 87974) http://127.0.0.1:8321
    replica-a up (process 87975) http://127.0.0.1:8323
    replica-b up (process 87976) http://127.0.0.1:8324
    replica-c up (process 87977) http://127.0.0.1:8325
    front up (process 87980) http://127.0.0.1:8322/front
    toolgate up (process 87984) http://127.0.0.1:8326

    Vos numéros de processus seront différents. toolgate est la passerelle d’outils de l’environnement. Sans PYTHONPATH, elle affiche NOT ANSWERING (ne répond pas), mais la passerelle de modèles fonctionne quand même. Cette leçon n’utilise pas la passerelle d’outils : la passerelle de modèles comprend front et les trois répliques.

  5. Dans le premier terminal, exécutez T-90104 par la passerelle, avec la capacité comme modèle :

    Fenêtre de terminal
    RESOLVER_PROVIDER=gateway ESTATE_STATE=vendor/ai-estate/state python -m resolver run T-90104 --variant agent_structured --model strong-reasoning

    Le résumé se termine par | unknown (inconnu) : à cette étape, le projet n’a aucun prix pour un nom de capacité.

  6. Affichez les spans de modèle : python show_spans.py chat. Chacun possède maintenant larkfield.gateway.model = chat-strong (gpt-6.1-sol-2026-09-29), un larkfield.gateway.request_id et un larkfield.gateway.cost_usd.

  7. Dans le deuxième terminal, lisez les derniers enregistrements de la passerelle : python -m estate usage --last 2. Comparez le traceparent de chaque enregistrement aux identifiants de span de l’étape 6. Comparez aussi ses tokens_in, tokens_out et cost_usd à ceux du span.

  8. Arrêtez l’environnement : python -m estate down. Chaque service affiche stopped (arrêté).

À vous de jouer : une application qui n’enregistre rien

Section intitulée « À vous de jouer : une application qui n’enregistre rien »

La principale affirmation de la passerelle est qu’elle voit même les appels d’applications sans aucune instrumentation. Vérifiez-la. Avec l’environnement en marche, envoyez un billet en désactivant le contexte de trace :

Fenêtre de terminal
RESOLVER_PROVIDER=gateway ESTATE_STATE=vendor/ai-estate/state OBS_GATEWAY_CONTEXT=off python -m resolver run T-80008 --variant agent_structured --model strong-reasoning

Dans PowerShell, ajoutez $env:OBS_GATEWAY_CONTEXT = "off" aux variables de l’étape 5. Avant de lire les enregistrements de la passerelle avec python -m estate usage --last 2, prédisez leurs champs. Prédisez aussi lequel sera absent.

Le résultat de l’équipe du cours
request_id 6b83b0dde924497e
agent_id support-workflow
team service
capability strong-reasoning
provider azure
deployment chat-strong
model_version gpt-6.1-sol-2026-09-29
tokens_in 2166
tokens_out 48
cost_usd 0.004812
status 200
outcome ok
run_id T-80008-agent_structured-strong-reasoning-1
fallback 0

Les lignes sur le temps, la réplique et la configuration sont omises ici. L’enregistrement contient l’agent, l’équipe, la capacité, le modèle, les jetons et le coût. La vue de la passerelle est complète sans aucune aide de l’application. Seule la ligne traceparent manque. L’identifiant d’exécution est présent parce que le flux de travail envoie encore X-Run-Id. Une application sans aucune instrumentation ne l’enverrait pas non plus. La passerelle peut donc compter chaque appel et son coût par agent. Mais elle ne peut pas dire quelle étape ou quelle exécution l’a fait.

Erreur courante

La passerelle n'est pas en marche

Symptôme : vous exécutez un billet avec RESOLVER_PROVIDER=gateway avant python -m estate up, ou après python -m estate down. L’exécution s’arrête immédiatement :

Run T-90104-agent_structured-strong-reasoning-1 | single agent with one JSON step per call (for models without tool calling) | strong-reasoning
Stopped: provider_error. No proposal: the ticket goes to a person.
Last error: Cannot reach the platform's token endpoint: <urlopen error [Errno 61] Connection refused>

Sous Linux, le nombre est 111; sous Windows, 10061 (non testé). Si vous n’avez jamais créé les identifiants de connexion, l’exécution s’arrête plus tôt. Elle affiche No credentials at … (aucun identifiant de connexion à cet emplacement) et la commande qui les crée.

Cause : le flux de travail demande d’abord un jeton au plan de contrôle de l’environnement, sur le port 8321. Rien ne répond. Le flux de travail choisit l’option sûre : aucune proposition, et le billet est transmis à une personne.

Diagnostic : python -m obs trace T-90104 montre un span chat strong-reasoning, ERROR ProviderError (erreur du fournisseur) et le résultat handed_to_person | stopped: provider_error (transmis à une personne, arrêté pour une erreur du fournisseur). python -m estate usage --last 1 ne montre aucun enregistrement de cet appel. Cette défaillance apparaît seulement dans la vue de l’application : l’appel n’a jamais atteint la passerelle.

Rétablissement : démarrez l’environnement dans le deuxième terminal (python -m estate up) et exécutez de nouveau le billet. Les deux vues révèlent donc des défaillances à des endroits différents. L’enregistrement de la passerelle explique un appel refusé par le fournisseur. Un appel qui n’atteint jamais la passerelle apparaît seulement dans la trace de l’application.

Utilisez les enregistrements de la passerelle pour les questions sur les agents et l’argent. Ils montrent le coût par agent enregistré et par équipe, le modèle qui a réellement répondu et les appels refusés. Ils montrent aussi les applications qui n’enregistrent rien. Utilisez les traces pour les questions sur les exécutions : quelle étape a fait un appel, ce que les outils ont fait, qui a approuvé et ce que le client a reçu. Utilisez les deux, reliés, pour les questions intermédiaires, comme « quelle étape de quelle exécution a fait cet appel coûteux? »

La jointure coûte deux en-têtes par appel : le traceparent du vrai span chat et l’identifiant d’exécution. Envoyez le vrai contexte, jamais un contexte inventé à partir d’un autre identifiant. Enregistrez les en-têtes de réponse de la passerelle sur le span. L’application connaît ainsi le modèle derrière une capacité. Autre contrôle à connaître : la passerelle limite chaque agent, à 120 requêtes par minute pour le flux de travail. Lors de l’exécution de l’équipe du cours, la passerelle a refusé un deuxième passage des 70 tâches dans la même minute. Elle a répondu avec HTTP 429. L’équipe a donc attendu 1,2 seconde entre les tâches. Vérifiez ensuite, comme dans le cours, que les deux totaux concordent : 310 041 et 15 702 jetons des deux côtés, et 0,77710 $ US. Une différence est un constat : un appel refusé, une nouvelle tentative ou une table de prix périmée.

Vérifiez votre compréhension

Le flux de travail du cours de gouvernance envoyait un traceparent avec chaque appel. Pourtant, aucun des 135 enregistrements ne correspondait à un span. Pourquoi, et que faut-il pour les relier?

Afficher la réponse

Son traceparent était créé à partir de l’identifiant d’exécution : un identifiant de trace inventé par exécution et un identifiant de span aléatoire par appel. Aucun span des traces du flux de travail n’avait donc cet identifiant. Pour les relier, il faut le contexte du vrai span de conversation : son identifiant de trace et son identifiant de span réels. Avec ce contexte, les 135 enregistrements correspondaient à leur span. Un traceparent n’est utile que s’il est réel.

Vérifiez votre compréhension

Kwame dit : « La passerelle enregistre chaque appel de modèle, avec les jetons et le coût. On n'a plus besoin des traces. » Nommez deux questions auxquelles la passerelle ne peut pas répondre, avec les chiffres de l'exécution du cours.

Afficher la réponse

La passerelle ne voit jamais ce qui se passe entre les appels de modèle. Cela comprend les 83 appels d’outils et les 28 demandes d’approbation des 70 exécutions, les écritures, la réponse et le résultat. Elle ne peut donc pas dire qu’une exécution a versé un remboursement deux fois, ni qui l’a approuvé. Sans le contexte de trace, elle ne peut pas non plus dire quelle étape a fait un appel. L’identifiant d’exécution relie seulement un enregistrement à une exécution de deux ou trois appels. De leur côté, les traces ne voient ni les appels refusés ni les applications sans instrumentation. Les deux vues servent donc ensemble.

Vérifiez votre compréhension

Vérification pratique : utilisez votre propre exécution avec la passerelle en production, ou l'exécution sauvegardée. Reliez un enregistrement de la passerelle à son span. Montrez que le modèle, les jetons et le coût concordent.

Afficher la réponse

Prenez un enregistrement de python -m estate usage –last 2, ou de gateway-usage.json. Prenez aussi le span de python show_spans.py chat, ou de obs trace avec les données sauvegardées. L’identifiant de span dans le traceparent de l’enregistrement correspond à celui du span de conversation. Par exemple, c’est e41cc07e075559ae dans l’exécution de l’équipe du cours. Les champs deployment et model_version de l’enregistrement correspondent au champ larkfield.gateway.model du span : chat-strong (gpt-6.1-sol-2026-09-29). Les champs tokens_in et tokens_out correspondent à gen_ai.usage.input_tokens et output_tokens (2 426 et 218). Le champ cost_usd correspond à larkfield.gateway.cost_usd (0,007032).

Récapitulatif

  • Une passerelle d’IA enregistre chaque appel de modèle : l’agent, son équipe, la capacité, le modèle qui a répondu, les jetons, le coût et les refus. Elle le fait même pour les applications qui n’enregistrent rien.
  • Seules les traces de l’application voient l’exécution : les appels d’outils, les approbations, les écritures et le résultat.
  • Reliez les deux par le contexte de trace réel (un enregistrement, un span), l’identifiant d’exécution (une exécution) et l’identifiant d’agent (un agent). Un traceparent inventé à partir de l’identifiant d’exécution ne relie rien : 0 sur 135.
  • Enregistrez les en-têtes de réponse de la passerelle sur le span, pour qu’un nom de capacité ne masque pas le modèle. Dans l’exécution du cours, les jetons et le coût concordaient exactement : 310 041 et 15 702 jetons, 0,77710 $ US.

Votre projet correspond maintenant à l’instantané end-of-m03, avec 86 tests réussis (87 avec le paquet MCP), plus votre show_spans.py. Dans ce module, vous avez instrumenté chaque appel de modèle, appel d’outil, approbation, passage de relais et appel à la passerelle. Le double remboursement forme maintenant une histoire où tout est relié. Mais une histoire n’est utile que si vous pouvez la lire rapidement et trouver les exécutions à lire. Ensuite, dans le module 4, vous lirez une exécution dans Grafana et trouverez les défaillances d’agents qu’elle contient.

Leçon suivante : Lire une exécution