Aller au contenu
English

Le Collector

  • Leçon 6
  • 45 min
  • Module 2 : OpenTelemetry pour les agents

Où nous en sommes

Dans les deux dernières leçons, nous avons regroupé chaque exécution dans une trace et nommé ses *spans* (unités de suivi) selon les outils. Mais les spans vont encore dans des fichiers sur un seul ordinateur. Où devraient-ils aller, et qui retire les données qui ne doivent pas sortir? Dans cette leçon, nous plaçons le Collector OpenTelemetry entre l'application et les outils. Nous lui confions le masquage, l'échantillonnage et le routage au même endroit. Nous commençons dans la salle du courrier d'un immeuble de bureaux.

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

Ce que vous saurez faire

Envoyez la télémétrie du flux de travail à un seul endroit, hors de l’application. Cet endroit retire le texte privé, conserve les traces importantes et dirige chaque signal vers son outil. L’application n’a jamais besoin de connaître la destination de ses données.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 45 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre projet dans l’état où la dernière leçon l’a laissé (79 tests réussis).
  • Facultatif, pour la dernière partie : environ 470 Mo d’espace disque libre pour le programme du Collector. Le téléchargement fait 97 Mo et produit un fichier de 363 Mo après décompression. Docker n’est pas nécessaire.

Testé sur macOS (Apple silicon) avec Python 3.12.13 et otelcol-contrib 0.162.0. Les chiffres de la semaine complète viennent d’une exécution mesurée par l’équipe du cours. Les commandes Windows et Linux ont été écrites, mais pas exécutées.

Un immeuble de bureaux compte cinquante entreprises et une salle du courrier. Chaque entreprise dépose ses lettres à envoyer dans le même bac, et ne connaît que ce bac. La salle du courrier fait le reste. Elle vérifie qu’aucune enveloppe n’affiche un numéro de carte bancaire. Elle envoie les lettres ordinaires par le service de messagerie économique, et les lettres recommandées par celui qui signe leur réception. Certaines lettres vont à deux endroits : chez le client et aux archives.

Quand l’immeuble change de service de messagerie, aucune entreprise ne change quoi que ce soit. Les entreprises ne connaissaient même pas l’adresse de l’ancien service.

Jusqu’ici, le flux de travail écrit sa télémétrie dans des fichiers. En production, les traces doivent aller à Tempo, les métriques à Prometheus et les événements à Loki, les outils Grafana du module 1. Au module 8, les traces vont aussi à Langfuse. Au module 6, les événements d’audit vont dans un stockage d’audit. Supposons que l’application envoie elle-même les données à chacun. Quatre problèmes se présentent.

Chaque application détient toutes les adresses et toutes les clés. La clé Langfuse serait dans les paramètres du flux de travail. Elle serait aussi dans les paramètres de chaque autre application qui envoie des traces.

Chaque application doit retirer elle-même le texte privé, et l’une d’elles va oublier. L’équipe du cours a rejoué la semaine en changeant un paramètre, comme un développeur pourrait le faire pour déboguer une requête : OBS_CAPTURE_CONTENT=on. L’exportation de l’application contenait alors 718 spans de modèle avec le texte des requêtes. Ce texte provenait des billets de soutien des clients, envoyés à chaque destination connue de l’application.

L’application ne peut pas bien échantillonner. Pour conserver chaque trace avec une erreur et seulement certaines traces ordinaires, vous devez d’abord voir la trace complète. L’application décide au début d’un span, avant de savoir comment l’exécution se termine.

Certaines données ne doivent jamais être échantillonnées ni mélangées. Tous les événements d’audit doivent arriver, et uniquement au stockage d’audit. Un outil de journalisation n’est pas le bon endroit pour eux.

L’idée : un Collector entre l’application et les outils

Section intitulée « L’idée : un Collector entre l’application et les outils »

Le Collector OpenTelemetry est un programme distinct qui reçoit la télémétrie, la modifie, puis la transmet. C’est la salle du courrier. L’application envoie tout à une seule adresse, OTEL_EXPORTER_OTLP_ENDPOINT, par OTLP. Le Collector connaît le reste.

La configuration d’un Collector comprend trois types de composants, réunis dans des pipelines, un par signal :

  • Un récepteur reçoit la télémétrie. Le nôtre est otlp : gRPC sur le port 4317 et HTTP sur le port 4318.
  • Un processeur modifie les données au passage. Les nôtres limitent la mémoire, retirent le texte (masquage), conservent certaines traces (échantillonnage) et regroupent les données en lots.
  • Un exportateur envoie les données : vers Tempo, Prometheus, Loki, Langfuse ou un fichier.

Un connecteur relie deux pipelines : il est exportateur pour l’un et récepteur pour le suivant. Le nôtre, routing, envoie les événements d’audit dans leur propre pipeline. Et quand un pipeline a deux exportateurs, les mêmes données vont aux deux : c’est la diffusion multiple (fan-out).

Le flux de travail envoie les données par OTLP à une seule adresse, 127.0.0.1:4318. Dans le cadre « Le Collector OpenTelemetry », le récepteur otlp (gRPC 4317, HTTP 4318) alimente trois pipelines. Traces : memory_limiter, transform/redact, tail_sampling, batch, puis vers Tempo. Une flèche pointillée montre la diffusion multiple vers Langfuse par un deuxième exportateur du même pipeline (module 8). Métriques : memory_limiter, batch, puis Prometheus. Événements : memory_limiter, puis un connecteur de routage qui demande : possède audit.type? Non : autres événements, transform/redact, batch, puis Loki. Oui : jamais échantillonnés, jamais vers Loki, vers le stockage d'audit (module 6).
Le Collector du cours (collector/otelcol-config.yaml) : un récepteur, un pipeline par signal, masquage et échantillonnage des traces, routage des événements d'audit et diffusion multiple vers une deuxième destination.
Description textuelle du diagramme

Lisez le schéma de gauche à droite. Le flux de travail connaît une seule adresse. Le récepteur reçoit chaque signal. Les traces passent par le masquage et l’échantillonnage en fin de trace, puis vont à Tempo. Au module 8, elles vont aussi à Langfuse. Les métriques vont à Prometheus. Les événements vont à un connecteur de routage. Un événement avec un attribut audit.type va uniquement au stockage d’audit, et il n’est jamais échantillonné. Chaque autre événement est masqué et va à Loki.

Le processeur transform/redact exécute des instructions sur chaque span. Deux types d’instructions font le travail :

- delete_key(attributes, "gen_ai.input.messages")
- replace_all_patterns(attributes, "value", "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}", "[email]")
- replace_all_patterns(attributes, "value", "\\b(?:\\d[ -]?){13,19}\\b", "[card number]")

La première supprime un attribut qui contient du texte selon les conventions GenAI. Sept clés de ce type sont supprimées : la requête, la réponse, les instructions système, les arguments et le résultat d’un outil, et deux anciens noms. Les deux suivantes examinent toutes les autres valeurs. Le premier motif reconnaît une adresse courriel. Le deuxième reconnaît de 13 à 19 chiffres, avec des espaces ou des tirets facultatifs : la forme d’un numéro de carte.

L’équipe du cours a envoyé un span inventé dans le Collector pour le vérifier. Son attribut larkfield.note était :

Write to sam.example@example.com, card 4111 1111 1111 1111

L’adresse est inventée, et 4111 1111 1111 1111 est un numéro de carte de test bien connu. Le Collector a produit :

Write to [email], card [card number]

Le deuxième motif a donc reconnu les 16 chiffres avec leurs espaces, et le premier a reconnu l’adresse. Sur la semaine complète avec la capture du contenu activée, l’exportation de l’application avait 718 problèmes. La sortie du Collector en avait 0.

C’est la défense en profondeur. Par défaut, le flux de travail n’enregistre aucun texte. Le Collector le retire aussi, au cas où une bibliothèque ou un paramètre de débogage en ajouterait. Aucune des deux couches ne fait confiance à l’autre.

L’échantillonnage en fin de trace, une trace à la fois

Section intitulée « L’échantillonnage en fin de trace, une trace à la fois »

Stocker chaque trace coûte de l’argent, et la plupart des exécutions sont ordinaires. L’échantillonnage n’en conserve qu’une partie. L’échantillonnage en début de trace décide au hasard, quand le premier span commence. L’échantillonnage en fin de trace attend que la trace soit complète, puis décide selon ses spans. Le Collector du cours attend 10 secondes (decision_wait: 10s), puis conserve une trace si au moins une politique le demande :

Politique Conserve une trace quand…
errors un span a le statut ERROR (erreur)
writes-and-approvals un span a gen_ai.operation.name = approve
write-calls un span a larkfield.tool.kind = write
injected-input un span a larkfield.input.injection = true
slow-runs la trace dure plus de 30 secondes
ten-percent-of-the-rest elle fait partie d’un échantillon aléatoire de 10 % des autres

Appliquez ces règles à la main aux deux traces du double remboursement. La trace 1 contient l’agent, deux appels de modèle, une lecture et la demande d’approbation. Aucune erreur, aucune approbation, aucune écriture : seule la probabilité de 10 % peut la conserver. La trace 2 contient approve support-resolution et les écritures de remboursement : elle remplit deux critères de conservation. Le Collector conserve donc habituellement la moitié de l’histoire avec les remboursements, et élimine celle avec la décision du modèle.

C’est ce qui s’est produit sur la semaine complète :

Mesure : la semaine rejouée (434 traces) dans le Collector autonome avec l'échantillonnage en fin de trace du cours. Chaque trace compte une fois, sous le premier motif applicable; l'échantillon de 10 % varie d'une exécution à l'autre. Une des traces d'écriture est le test de masquage construit.
Description textuelle du graphique

Six barres. Conservées pour une approbation : 100 traces. Pour une écriture : 95. Pour une erreur : 53. Pour une entrée injectée : 13. Par l’échantillon de 10 % : 15. Éliminées : 159 sur 434 traces. Le nombre de spans est passé de 2027 à 1287.

Chaque trace avec une erreur, une approbation ou une écriture a été conservée. Mais 99 exécutions ont perdu une de leurs deux traces, comme ce serait le cas pour la première trace du double remboursement. Les politiques décident trace par trace, et une exécution avec une approbation a deux traces. Le module 3 explique pourquoi une exécution a deux traces.

Tomás dit : « L’échantillonnage convient à tout. » Il convient aux traces ordinaires. Il ne convient pas aux événements d’audit : une piste d’audit avec 10 % de ses enregistrements n’est pas une piste d’audit. Le processeur tail_sampling est donc uniquement dans le pipeline des traces. Dans cette même exécution, les 1331 événements d’audit ont tous atteint le stockage d’audit, et aucun n’a atteint la sortie Loki. Le module 6 construit ce stockage.

  1. Copiez les configurations du Collector, le programme de simulation de la semaine, le nouveau test, le fichier compose de Grafana et le README depuis l’instantané :

    Fenêtre de terminal
    S=../nextia-learning-labs/C31/snapshots/end-of-m02
    cp -R $S/collector $S/scenarios .
    cp $S/tests/test_collector_files.py tests/
    cp $S/grafana/compose.yaml grafana/
    cp $S/README.md .
  2. Exécutez les tests : python -m pytest -q. La dernière ligne indique 81 passed, 1 deselected (81 tests réussis, 1 test non sélectionné). Votre projet est maintenant identique à l’instantané end-of-m02. Les deux nouveaux tests lisent la configuration. Ils vérifient la présence du masquage, l’échantillonnage en fin de trace uniquement dans le pipeline des traces, et le routage distinct des événements d’audit.

  3. Ouvrez collector/otelcol-config.yaml. Trouvez les quatre parties du schéma : receivers (récepteurs), processors (processeurs), connectors (connecteurs) et exporters (exportateurs). Trouvez ensuite service.pipelines à la fin : chaque pipeline énumère ses récepteurs, processeurs et exportateurs, dans l’ordre.

  4. Ouvrez grafana/compose.yaml. Il monte maintenant collector/otelcol-config.yaml à la place de la configuration du Collector dans le conteneur Grafana. Quand vous utilisez Grafana, son Collector applique donc le même masquage, le même échantillonnage et le même routage. Le module 4 montre comment le démarrer et lui envoyer une semaine. Si Grafana fonctionne, redémarrez-le pour charger le fichier : docker compose -f grafana/compose.yaml down, puis up -d.

  5. Trouvez les exportateurs. Leurs adresses sont celles de Tempo, de Prometheus, de Loki et du stockage d’audit. Cherchez-les ensuite dans le code du flux de travail : grep -rn "4418\|9090\|3100" resolver/ (PowerShell : Select-String -Path resolver\*.py -Pattern "4418|9090|3100"). La recherche ne trouve rien. Le flux de travail connaît seulement OTEL_EXPORTER_OTLP_ENDPOINT.

  6. Vérifiez votre propre télémétrie : python -m obs check-redaction work/telemetry. Cette commande lit chaque attribut, comme le fait le masquage.

    Checked 4 span(s), 0 event(s), 4 metric line(s) in work/telemetry.
    No text attribute, no e-mail address and no card number found.

    Vos nombres dépendent du nombre d’exécutions que vous avez faites.

Essayez maintenant le paramètre de débogage qui a causé les 718 problèmes :

Fenêtre de terminal
rm -rf work
OBS_CAPTURE_CONTENT=on python -m resolver run T-80008
python -m obs check-redaction work/telemetry

Dans PowerShell, utilisez Remove-Item -Recurse work et $env:OBS_CAPTURE_CONTENT = "on", puis retirez la variable après. La vérification indique encore No text attribute, no e-mail address and no card number found. (aucun attribut de texte, aucune adresse courriel et aucun numéro de carte trouvés). Pourquoi? À ce stade, votre flux de travail enregistre seulement le span d’exécution, et le texte serait dans les spans de modèle. Le module 3 les ajoute. L’équipe du cours a fait son exécution à la fin du cours, avec tous les spans de modèle.

L’instantané contient aussi le programme de simulation de la semaine, qui rejoue la semaine avec votre propre code :

Fenêtre de terminal
python -m scenarios week --out work/week
week: 316 runs in 1 s -> work/week
resolved 203, right by the course's labels 273
scenario runs: double_refund 2, hidden_tool_error 1, injection_seen 22, local_model 16, loop 3, model_switch 40, no_action 4, non_english 14, overnight_approval 19

Les mêmes 316 exécutions que la semaine sauvegardée, avec l’instrumentation actuelle : python -m obs trace R-1014-040 --data work/week affiche un seul span, celui de l’exécution, et le résultat waiting_approval (en attente d’approbation). La semaine sauvegardée a été produite à la fin du cours, elle contient donc tous les spans.

Pourquoi l’application ne devrait pas connaître la destination de ses données

Section intitulée « Pourquoi l’application ne devrait pas connaître la destination de ses données »

Regardez ce que chaque côté connaît maintenant. Le flux de travail connaît une adresse et ce qu’il enregistre. Le Collector connaît les destinations, leurs clés, ce qu’il faut retirer et ce qu’il faut conserver. Chaque changement se fait d’un seul côté :

  • Kwame déplace les traces vers un autre système de stockage : il change un exportateur. Le flux de travail ne change pas.
  • Mei réduit la durée de conservation des traces, ou Priya veut plus de traces ordinaires : elles changent la politique d’échantillonnage.
  • Larkfield ajoute Langfuse au module 8 : un exportateur de plus dans le pipeline des traces. C’est la diffusion multiple.
  • Une nouvelle application s’ajoute : elle envoie à la même adresse et bénéficie du même masquage.

C’est aussi plus sûr. Une clé dans la configuration d’un Collector se trouve à un seul endroit, lu par un seul processus. Une clé dans chaque application se trouve dans les paramètres, les journaux et les rapports de plantage de chaque application.

Le Collector est un programme de plus à exécuter, à mettre à jour et à surveiller. S’il s’arrête, la télémétrie s’arrête : l’exportateur de l’application réessaie un moment, puis abandonne les données. L’échantillonnage en fin de trace garde chaque trace en mémoire pendant 10 secondes, jusqu’à num_traces: 20000. Le processeur memory_limiter refuse les données au-delà de 400 Mio. Le Collector se protège donc au lieu de planter. L’échantillonnage perd des données volontairement : une trace éliminée est perdue. Et un Collector peut seulement retirer ce que ses règles décrivent : un nouveau type de données privées exige une nouvelle règle. La commande check-redaction vérifie la sortie, ce qui permet à un test de détecter une règle manquante.

Pour une seule personne qui développe sur un portable, les fichiers suffisent, et les leçons du cours les utilisent. Pour une équipe, les règles se trouvent dans le Collector.

Le Collector du cours utilise la distribution contrib d’OpenTelemetry Collector, otelcol-contrib 0.162.0. Dans Docker, il s’exécute dans l’image grafana/otel-lgtm du module 1. Sans Docker, collector/standalone.yaml exécute les mêmes processeurs et écrit des fichiers au lieu d’envoyer les données à Grafana.

Les noms des composants changent selon les versions : cette version nomme l’exportateur HTTP otlp_http. Les exemples plus anciens sur le Web utilisent otlphttp. Utilisez les noms de la version que vous exécutez.

  1. Téléchargez la version pour votre ordinateur depuis la page des versions du projet, dans un dossier voisin de votre projet. Vérifiez son SHA-256 avec le fichier .sha256 de la même version.

    Fenêtre de terminal
    mkdir -p ../otelcol && cd ../otelcol
    curl -LO https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v0.162.0/otelcol-contrib_0.162.0_darwin_arm64.tar.gz
    shasum -a 256 otelcol-contrib_0.162.0_darwin_arm64.tar.gz
    tar -xzf otelcol-contrib_0.162.0_darwin_arm64.tar.gz otelcol-contrib
    cd ../observable-workflow

    La somme de contrôle doit être d5e11974d2e4adac3cc001a25137aad52f6e77ec3034ba7735cac7c219a5f97a.

  2. Dans un premier terminal, dans le dossier du projet, démarrez le Collector. Il écrit sa sortie dans work/collector-out. AUDIT_STORE_URL désigne le stockage d’audit du module 6. Rien n’y écoute encore et aucun événement d’audit n’existe encore, donc rien n’est envoyé.

    Fenêtre de terminal
    mkdir -p work/collector-out
    OUT_DIR=work/collector-out AUDIT_STORE_URL=http://127.0.0.1:8313 ../otelcol/otelcol-contrib --config collector/standalone.yaml
  3. Dans un deuxième terminal, avec l’environnement virtuel actif, envoyez deux exécutions au Collector plutôt qu’aux fichiers. T-80002 correspond au refus enregistré du filtre de contenu, donc son span d’exécution a le statut ERROR (erreur). T-80008 est une exécution ordinaire.

    Fenêtre de terminal
    OBS_EXPORT=otlp python -m resolver run T-80002
    OBS_EXPORT=otlp python -m resolver run T-80008

    Dans PowerShell, définissez d’abord $env:OBS_EXPORT = "otlp".

  4. Exécutez T-80008 neuf fois de plus, de la même façon. Attendez ensuite environ 15 secondes : 10 pour la décision d’échantillonnage, puis le lot. Listez ce que le Collector a laissé sortir et vérifiez le résultat :

    Fenêtre de terminal
    python -m obs runs --data work/collector-out
    python -m obs check-redaction work/collector-out
  5. Arrêtez le Collector avec Ctrl+C dans le premier terminal.

L’essai du cours a envoyé onze exécutions et en a reçu deux :

run ticket started outcome model tools appr cost US$ secs model flags
T-80002-agent-chat-small-1 T-80002 … handed_to_person 0 0 0 0.00000 0.0 chat-small -
T-80008-agent-chat-small-10 T-80008 … resolved 0 0 0 0.00000 0.0 chat-small -
2 run(s), 0 flagged
Checked 2 span(s), 0 event(s), 11 metric line(s) in work/collector-out.
No text attribute, no e-mail address and no card number found.

L’exécution de T-80002 est présente parce que la politique errors (erreurs) la conserve. Sur les dix exécutions ordinaires de T-80008, l’échantillon de 10 % en a conservé une, ici la dixième. Votre nombre sera différent : l’échantillon est aléatoire. Toutes les métriques sont arrivées : l’échantillonnage concerne seulement les traces. Le Collector n’a enregistré aucune erreur, même si aucun stockage d’audit n’écoute encore.

Erreur courante

Mon exécution n'est pas dans la sortie du Collector

Symptôme : après OBS_EXPORT=otlp python -m resolver run T-80008, python -m obs runs --data work/collector-out ne liste pas l’exécution, mais obs liste T-80002.

Cause : l’échantillonnage en fin de trace fonctionne comme prévu. La trace de T-80008 n’a ni erreur, ni approbation, ni écriture, ni entrée injectée. Seule la politique de 10 % peut donc la conserver. Il peut aussi être trop tôt : le Collector attend 10 secondes avant de décider, puis envoie un lot.

Diagnostic : attendez 15 secondes et listez de nouveau les exécutions. Vérifiez à quelles politiques la trace pourrait correspondre : ouvrez ses spans dans work/telemetry. Avec OBS_EXPORT=file,otlp, le flux de travail écrit aux deux endroits.

Solution : rien n’est défectueux. Pour vous exercer, utilisez OBS_EXPORT=file,otlp pour garder votre propre copie de chaque exécution. En production, choisissez délibérément les traces à toujours conserver et écrivez une politique pour elles.

Erreur courante

Le Collector s'arrête immédiatement

Symptôme : le Collector affiche une erreur et s’arrête juste après son démarrage. Sans AUDIT_STORE_URL, l’essai du cours a affiché un avertissement, puis :

Error: invalid configuration: exporters::otlp_http/audit: at least one endpoint must be specified

Cause : il s’agit généralement d’une de ces trois situations. OUT_DIR ou AUDIT_STORE_URL n’est pas définie dans ce terminal, donc la configuration contient une valeur vide, comme ci-dessus. Un autre programme utilise le port 4317, 4318 ou 13133. Ou la configuration contient un nom de composant d’une autre version.

Diagnostic : lisez la première ligne d’erreur. Elle nomme le composant ou le port.

Solution : définissez les deux variables dans le même terminal. Arrêtez l’autre programme, par exemple un conteneur Grafana du module 1 : docker compose -f grafana/compose.yaml down. Ou utilisez les noms de la version 0.162.0.

Vérification de fin : dessiner un arbre à partir d’une liste de spans

Section intitulée « Vérification de fin : dessiner un arbre à partir d’une liste de spans »

Voici les huit spans d’une exécution, tels qu’un outil les liste. Cette exécution fait intervenir les deux processus sur T-90103, rejoués avec le projet du module 3. Chaque ligne donne les quatre premiers caractères de l’identifiant du span et de celui de son parent. Viennent ensuite le début, en secondes depuis le début de la trace, et la durée.

Span Parent Début (s) Durée (s) Nom
4f2b – 0.00 4.97 invoke_workflow support-resolution
af66 4f2b 0.00 3.47 invoke_agent investigator
f727 af66 0.00 1.26 chat chat-small
45d7 af66 1.26 0.01 execute_tool get_order
35b4 af66 1.27 2.20 chat chat-small
c4c7 0b3d 3.47 1.49 chat chat-small
0b3d 4f2b 3.47 1.49 invoke_agent resolver
0fc9 4f2b 4.95 0.02 execute_tool send_reply

Vérifiez votre compréhension

Tomás dit : « On n'enregistre déjà aucun texte, donc un processeur de masquage dans le Collector, c'est du travail inutile. » Répondez-lui avec la mesure du cours.

Afficher la réponse

Le flux de travail n’enregistre aucun texte par défaut, mais un seul réglage de débogage change cela. Avec la capture du contenu activée, l’exportation de l’application contenait 718 spans de modèle avec du texte de requête. Une nouvelle bibliothèque pourrait faire la même chose sans que personne le remarque. Le Collector les a tous retirés. Il a aussi transformé une sonde contenant une adresse courriel et un numéro de carte de test en Write to [email], card [card number] (écrire à [courriel], carte [numéro de carte]). Deux couches qui ne se font pas confiance constituent une défense en profondeur. Cela ne coûte que quelques instructions dans un fichier de configuration.

Vérifiez votre compréhension

Pourquoi l'échantillonnage en fin de trace concerne-t-il seulement le pipeline des traces? Qu'a-t-il coûté aux exécutions comme celle du double remboursement?

Afficher la réponse

Tous les événements d’audit doivent arriver, et seulement au stockage d’audit. Ils ne sont donc jamais échantillonnés. Le connecteur de routage les envoie dans leur propre pipeline, et les 1 331 événements sont tous arrivés. Les métriques sont déjà de petits décomptes. Pour les traces, les politiques conservent chaque trace avec une erreur, une approbation ou une écriture, et 10 % des autres. Mais elles décident trace par trace : 99 exécutions avec deux traces en ont perdu une. La première trace d’un double remboursement, la décision du modèle, n’a ni erreur ni écriture. Elle est donc généralement supprimée, tandis que sa trace d’approbation est conservée.

Vérifiez votre compréhension

Vérification de fin de ce module : dessinez l'arbre de trace des huit spans du tableau ci-dessus. Nommez l'étape la plus longue. Expliquez pourquoi le span racine n'est pas la réponse.

Afficher la réponse

La racine est 4f2b, invoke_workflow support-resolution, sans parent : 4,97 s, soit l’exécution entière. Elle a trois enfants : af66 invoke_agent investigator (3,47 s), 0b3d invoke_agent resolver (1,49 s) et 0fc9 execute_tool send_reply. L’agent investigator a trois enfants : un appel de modèle (1,26 s), execute_tool get_order et un deuxième appel de modèle (2,20 s). L’agent resolver a un enfant, c4c7, un appel de modèle de 1,49 s. Son identifiant de parent désigne resolver, même si la liste le place avant resolver : les deux commencent au même moment. L’étape la plus longue sous la racine est investigator, à 3,47 s. L’appel individuel le plus long est le deuxième appel de modèle d’investigator, à 2,20 s. La racine dure plus longtemps, mais elle représente l’exécution entière, pas une étape.

Récapitulatif

  • Le Collector reçoit, traite et exporte les données, dans un pipeline par signal. L’application connaît une seule adresse.
  • Le masquage supprime les attributs textuels GenAI et masque les adresses courriel et les numéros de carte. Pendant la semaine avec la capture du contenu activée : 718 problèmes dans l’exportation de l’application, 0 après le Collector.
  • L’échantillonnage en fin de trace décide par trace après 10 s : 434 traces sont devenues 275. Chaque erreur, approbation et écriture a été conservée, et 99 exécutions ont perdu une de leurs deux traces.
  • Les événements d’audit ont leur propre route : jamais échantillonnés, jamais dans Loki. La diffusion vers plusieurs destinations envoie les mêmes traces à un deuxième outil.
  • Le Collector exige un programme à exécuter et de la mémoire pour garder les traces; il contient les règles de l’équipe.
  • Votre projet correspond maintenant à l’instantané end-of-m02 : 81 tests réussissent.

Vous pouvez maintenant envoyer la télémétrie d’une exécution par un point unique qui la nettoie, l’échantillonne et l’achemine. Mais une exécution de notre flux de travail reste un seul span. Les appels de modèle, les appels d’outils et les 15 heures d’attente pour Sam n’y figurent pas encore. Ensuite, au module 3, vous enregistrez chaque appel de modèle avec son modèle, ses jetons et sa version de requête. Vous n’enregistrez pas son texte.

Leçon suivante : Appels de modèle et jetons