Aller au contenu
English

Une observabilité qui respecte la vie privée

  • Leçon 10
  • 50 min
  • Module 3 : Instrumenter une télémétrie utile

Où nous en sommes

Dans les deux leçons précédentes, nous avons fait enregistrer par le service ce qui arrive à chaque billet, par version et avec son coût. Mais cet enregistrement copie ce que les clients ont écrit, et il peut donc le divulguer. Dans cette leçon, nous décidons ce que contient la télémétrie, nous retirons le texte privé avant qu'il quitte le service et nous mesurons le coût de chaque choix, comme une caméra de magasin qui ne doit pas filmer le terminal de paiement.

Ce que vous saurez faire

La télémétrie copie ce qui arrive au billet de chaque client. Elle peut donc divulguer ce que les clients ont écrit. Décidez ce qu’elle contient, puis retirez le texte privé avant qu’il quitte le service. Gardez moins de traces, limitez leur accès et leur durée de conservation, puis mesurez le coût de chaque choix.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre projet à l’instantané end-of-m03. Pour exécuter vous-même ces configurations, Docker pour PostgreSQL et Valkey, comme dans la première leçon de ce module.

Sans Docker, lisez les sorties de l’auteur ci-dessous, puis faites l’exercice guidé et la tâche à la fin. Ils utilisent seulement la télémétrie enregistrée.

Un magasin a une caméra de sécurité à l’entrée. Elle est utile : quand un colis disparaît, le propriétaire peut voir qui est entré. Mais si elle filme aussi le terminal de paiement à la caisse, chaque enregistrement contient les NIP des clients. Les enregistrements deviennent alors un danger, tout comme les personnes qui peuvent les regarder.

Un magasin prudent pointe donc la caméra ailleurs que vers le terminal de paiement. Il garde les enregistrements pendant 30 jours, puis les supprime. Il verrouille la pièce où se trouve l’écran, et seulement deux personnes ont la clé. Il ne garde pas non plus chaque minute de chaque caméra en pleine qualité; cela remplirait les disques.

Chacun de ces choix porte un nom en télémétrie. Pointer la caméra ailleurs, c’est la minimisation : ne pas recueillir ce dont vous n’avez pas besoin. Cacher une partie de l’image, c’est le caviardage. Supprimer après 30 jours, c’est la conservation. La pièce verrouillée représente le contrôle d’accès. Garder seulement certains enregistrements, c’est l’échantillonnage.

Tomás propose : « Mettons chaque requête et chaque réponse au complet dans les traces. Quand quelque chose brisera, nous aurons tout. »

Le service peut le faire. TELEMETRY_CAPTURE_CONTENT=true ajoute l’objet et le corps du billet, les messages envoyés au modèle, sa sortie et la réponse. L’auteur l’a exécuté en désactivant le caviardage (TELEMETRY_REDACT=false) et avec TELEMETRY_FILE=telemetry-raw/{service}.jsonl. Cette exécution a envoyé cinq billets d’exercice, puis un autre billet rédigé à la main :

Fenêtre de terminal
curl -X POST http://127.0.0.1:8000/v1/tickets -H "Content-Type: application/json" \
-d '{"customer_id": "C-0022", "subject": "Charged twice", "body": "I paid twice for one order. Please reply to sam.lee@example.com."}'

Ensuite, ops privacy a analysé les deux fichiers. Cette commande compte ce qu’elle trouve, mais n’affiche jamais le texte :

Fenêtre de terminal
python -m ops privacy telemetry-raw/ticket-api.jsonl telemetry-raw/ticket-worker.jsonl
ticket-api.jsonl, ticket-worker.jsonl: 6 tickets
signal KB KB per ticket
------ ----- -------------
log 10.1 1.68
metric 23.8 3.97
span 116.4 19.39
all 150.3 25.04
FOUND (counts only; the text is not printed):
attribute ticket.subject: 6
attribute ticket.body: 6
attribute answer.text: 6
attribute gen_ai.input.messages: 6
attribute gen_ai.output.messages: 6
e-mail address: 2

Le texte de chaque billet se retrouve maintenant cinq fois dans la télémétrie, et l’adresse courriel du client, deux fois. Ces fichiers vont dans Grafana, où chaque visiteur peut les consulter, dans les sauvegardes et sur un portable pour « regarder rapidement ». La base de données des billets définit qui peut les lire et quand ils sont supprimés. La télémétrie serait une deuxième copie des mêmes messages, sans ces règles.

Et « au cas où » est rarement rentable. Dans ce module, aucune réponse aux questions sur la semaine dernière n’a nécessité un seul mot d’un billet. Le résultat, les jetons, la raison de fin et la durée ont suffi.

L’idée : décider avant l’exportation, puis limiter le reste

Section intitulée « L’idée : décider avant l’exportation, puis limiter le reste »

Une observabilité qui respecte la vie privée répond aux questions d’exploitation avec le moins de données personnelles possible. Elle fonctionne par couches, du code jusqu’au lecteur :

Un flux de gauche à droite. D'abord, le code du service ajoute des attributs : tailles, langue, valeurs de hachage; du texte seulement si TELEMETRY_CAPTURE_CONTENT est vrai. Ensuite, un échantillonneur, pour les traces seulement : TELEMETRY_SAMPLE garde cette proportion des billets. Non conservée : une trace abandonnée, mais les journaux et les métriques comptent toujours le billet. Conservée : caviardage avant l'exportation, avec TELEMETRY_REDACT à vrai : retirer les attributs textuels, masquer les adresses courriel et les numéros de carte. Puis les fichiers et le collecteur. De là, deux limites : la conservation, avec TELEMETRY_RETENTION_DAYS, ops prune et les paramètres des systèmes de stockage; et l'accès en lecture, avec les visiteurs de Grafana comme Viewers et les autorisations des dossiers pour les fichiers.
Les couches de protection de la vie privée dans la télémétrie du service, du code au lecteur. Chaque couche a son propre paramètre.
Description textuelle du diagramme

Le code est la première couche : par défaut, il décrit le billet sans son texte. L’échantillonneur élimine la plupart des traces, mais jamais les journaux ni les métriques. Chaque billet reste donc compté. Le caviardage s’exécute dans le processus, avant tout exportateur. Le texte n’atteint donc jamais un fichier ni le réseau. Après l’exportation, la conservation détermine la durée de vie des données, et le contrôle d’accès détermine qui peut les lire.

La première couche est la plus importante : décrivez l’entrée, ne la copiez pas. La première leçon de ce module présentait l’événement ticket.received avec ticket.message_chars (la longueur), ticket.language_guess et ticket.message_sha256. Ces attributs décrivent suffisamment le message pour mesurer la dérive dans le prochain module et trouver les messages répétés. Aucun ne contient les mots.

Le caviardage est la protection de secours pour le texte qui s’ajoute malgré tout. Avant l’exportation, il retire chaque attribut contenant du texte rédigé par une personne. Il masque aussi les adresses courriel et les numéros de carte dans tout autre texte. Voici la fonction redact() du projet, exécutée seule sur un ensemble d’attributs :

>>> telemetry.redact({
... "ticket.body": "I paid twice for one order. Please reply to sam.lee@example.com.",
... "ticket.message_chars": 64,
... "note": "customer sam.lee@example.com, card 4111 1111 1111 1111",
... "team": "payment"})
{'ticket.message_chars': 64, 'note': 'customer [email], card [card]', 'team': 'payment'}

Le corps a disparu : il figure dans la liste des attributs textuels. La note reste, mais son adresse courriel et son numéro de carte sont masqués. La longueur et l’équipe restent, car ce ne sont pas des données personnelles. Le masquage utilise des motifs et détecte seulement ce qu’ils reconnaissent. Un nom ou une adresse postale dans du texte libre passe donc inaperçu. C’est pourquoi le retrait des attributs textuels vient en premier, et le masquage en second.

L’auteur a envoyé cinq autres billets d’exercice et le même billet rédigé à la main, avec le caviardage activé (TELEMETRY_CAPTURE_CONTENT=true, TELEMETRY_REDACT=true), dans telemetry-redacted/ :

ticket-api.jsonl, ticket-worker.jsonl: 6 tickets
signal KB KB per ticket
------ ---- -------------
log 7.4 1.23
metric 21.1 3.51
span 67.6 11.26
all 96.0 16.00
No text attribute, no e-mail address, no card number found.

Rien de détecté, et les segments de trace retrouvent leur taille normale. L’équipe du cours a mesuré les trois mêmes configurations sur 200 billets chacune. La taille fixe des métriques pèse ainsi moins lourd :

Kilooctets de télémétrie par billet (API et processus, toutes les traces conservées, 200 billets d'exercice par configuration), mesurés par l'équipe du cours. Le caviardage retire exactement ce que la capture du texte ajoute.
Description textuelle du graphique

Trois barres. Par défaut, sans texte : 12,9 Ko par billet. Texte conservé sans caviardage : 21,6 Ko, soit deux tiers de plus. Texte conservé avec caviardage : 12,9 Ko, comme par défaut. Dans la deuxième configuration, ops privacy a trouvé l’objet, le corps, la requête, la sortie du modèle et la réponse dans les 200 billets. Dans les deux autres, la commande n’a rien trouvé.

La troisième barre illustre la leçon. Capturer le texte, puis le caviarder donne exactement le résultat par défaut, avec un risque en plus. Le texte existe brièvement dans le processus, et un seul mauvais paramètre suffit à l’exporter. Larkfield garde donc la valeur par défaut, TELEMETRY_CAPTURE_CONTENT=false, et garde le caviardage activé comme protection de secours. Quand Priya a besoin du texte d’un billet qui a échoué, elle prend son identifiant dans la télémétrie. Elle lit ensuite le billet dans la base de données des billets, selon ses propres règles d’accès.

Échantillonnage : moins de traces, chaque billet toujours compté

Section intitulée « Échantillonnage : moins de traces, chaque billet toujours compté »

Les segments de trace occupent la majeure partie de l’espace : environ 11 des 12,9 Ko par billet. Un service très actif n’a pas besoin de la trace de chaque billet traité sans problème. L’échantillonnage garde les traces d’une partie seulement des billets. TELEMETRY_SAMPLE=0.1 en garde environ 1 sur 10.

La décision se prend une seule fois par trace, à partir de son identifiant, au début. Un billet garde donc tous ses segments de trace, ou aucun. Le segment du processus suit la décision de l’API, car la tâche transporte le traceparent (le contexte de la trace parente). Les journaux et les métriques ne sont jamais échantillonnés. Chaque SLI compte donc toujours chaque billet.

L’auteur a envoyé 20 billets d’exercice avec TELEMETRY_SAMPLE=0.1 et TELEMETRY_FILE=telemetry-10/{service}.jsonl, pour donner à chaque configuration ses propres fichiers :

Fenêtre de terminal
python -m ops summary telemetry-10/ticket-api.jsonl telemetry-10/ticket-worker.jsonl
Records: 40 logs, 88 spans, 42 metric records, from +0.0 min to +0.4 min
Ticket requests: 20 (202: 20)
Tickets triaged: 20 (ok: 20)

Les 20 billets sont tous comptés, à partir de 40 événements. Les 88 segments de trace forment 4 traces de 22 segments. Donc, 4 billets sur 20 ont gardé une trace, et non 2. Une proportion de 10 % est une probabilité, pas un nombre exact. Votre nombre sera différent. La taille a baissé à 4,94 Ko par billet. L’exécution de la première leçon, avec toutes les traces, occupait 18,58 Ko par billet, pour seulement 5 billets.

Les fichiers enregistrés du cours montrent le même effet à grande échelle. La semaine normale a gardé 10 % des traces : 34 412 enregistrements pour 5 754 billets, 20,4 Mo, et 2,2 Mo après compression. La réexécution de la semaine dernière a gardé toutes les traces : 56 334 enregistrements pour 2 400 billets, 34,1 Mo, et 2,6 Mo après compression. Par billet, cela représente environ 3,5 Ko contre 14,2 Ko.

L’échantillonnage réduit le travail du processus, mais pas celui de l’API :

Tâches par seconde pour un processus avec un simulateur qui répond immédiatement, médiane de trois passages, mesurée par l'équipe du cours. L'échantillonnage récupère la majeure partie du coût du traçage de chaque billet.
Description textuelle du graphique

Trois barres. Sans télémétrie, le processus terminait 238 tâches par seconde. Avec toutes les traces, 201 : 16 % de moins. Avec 10 % des traces, 229 : 4 % de moins. L’API montrait un autre résultat. Une requête de billet prenait une médiane de 2,39 ms sans télémétrie, de 3,66 ms avec toutes les traces et de 3,75 ms avec 10 %. L’API produit toujours ses journaux, ses métriques et son propre segment de trace pour chaque requête. L’échantillonnage n’a donc pas réduit son coût.

La conservation désigne la durée pendant laquelle la télémétrie est gardée. Le paramètre est TELEMETRY_RETENTION_DAYS=30 : assez longtemps pour comparer cette semaine au mois dernier et analyser un incident. ops prune supprime les anciens enregistrements d’un fichier :

Fenêtre de terminal
python -m ops prune telemetry/ticket-worker.jsonl --days 30
telemetry/ticket-worker.jsonl: kept 115 records, deleted 0 older than 30 days

N’exécutez pas prune sur les fichiers enregistrés du cours dans data/telemetry/. Ils ont été enregistrés bien avant votre lecture; la commande les supprimerait donc tous. Dans Grafana, chaque système de stockage a son propre paramètre (Prometheus, Loki et Tempo), indiqué dans observability/README.md. Mei est responsable du stockage de la télémétrie. Elle configure donc ces paramètres et les vérifie.

Le contrôle d’accès détermine qui peut lire la télémétrie. Dans compose.yaml, les personnes non connectées à Grafana sont des Viewers (lecteurs). Elles peuvent consulter les tableaux de bord, mais pas les modifier ni modifier les règles d’alerte. La valeur par défaut de l’image est Admin (administrateur); le projet la change donc. Sur votre ordinateur, le compte administrateur est admin et son mot de passe est admin. Changez-le avant que quelqu’un d’autre puisse accéder au port 3000. Les fichiers demandent la même attention. Le fichier .gitignore du projet contient déjà telemetry/ : ne mettez jamais ces fichiers dans un dépôt ou un message de clavardage.

Utilisez ces paramètres pour chaque service qui traite le texte des clients. Gardez la capture du contenu désactivée. Gardez le caviardage activé, même si le code par défaut n’envoie aucun texte. Il protège contre les erreurs de la prochaine personne qui ajoute un attribut.

Échantillonnez les traces quand leur volume devient un coût : stockage, réseau ou temps du processus. N’échantillonnez pas lorsque le trafic est faible, ni pendant le débogage : vous avez alors besoin de chaque trace. L’échantillonnage a aussi son propre coût réel. Un billet rare et lent peut n’avoir aucune trace. Pendant la semaine normale, seulement 570 billets sur 5 754 ont gardé une trace. Les grandes équipes utilisent l’échantillonnage en fin de trace (tail sampling). Le collecteur attend la fin d’une trace, puis garde chaque trace avec une erreur ou une longue durée. Ce projet ne le fait pas. Il garde les journaux de chaque billet; vous pouvez donc toujours trouver et compter un billet qui a échoué.

Une courte conservation coûte de l’historique : après 30 jours, les anciens billets ont disparu. Gardez les métriques plus longtemps que les traces si vous avez besoin de tendances : elles contiennent des nombres, pas des billets.

Erreur courante

Aucune trace pour le billet dont vous avez besoin

Symptôme : avec TELEMETRY_SAMPLE=0.1, la vue en cascade d’un billet affiche :

No trace for ticket T-500018: it was not sampled (TELEMETRY_SAMPLE keeps only some tickets' traces). Its logs are there: python -m ops trace.

Cause : l’identifiant de trace de ce billet se trouvait hors des 10 % que l’échantillonneur conserve. Dans l’exécution de l’auteur, 16 des 20 billets n’avaient aucune trace.

Solution : utilisez les journaux du billet. La commande ops trace, présentée dans Lignée des artefacts, les lit avec le résultat, les jetons et le coût. Pour déboguer un problème, configurez temporairement TELEMETRY_SAMPLE=1.0, puis envoyez le billet à nouveau.

Erreur courante

Une valeur de hachage n'est pas anonyme

Symptôme : quelqu’un suggère que la télémétrie ne contient aucune donnée personnelle, « seulement des valeurs de hachage ».

Cause : ticket.message_sha256 et customer.ref sont des pseudonymes. Le même texte, ou le même client, donne toujours la même valeur. Quiconque possède le message d’un client peut calculer son hachage et le retrouver dans la télémétrie. De nombreuses lois sur la vie privée considèrent encore ces valeurs comme des données personnelles.

Solution : traitez quand même la télémétrie comme des données personnelles : conservation, contrôle d’accès et aucune copie hors de l’équipe. Demandez à votre responsable de la vie privée quelles règles s’appliquent à vous. Les valeurs de hachage sont volontairement courtes (16 et 10 caractères). Elles suffisent pour trouver des répétitions, mais sont moins utiles comme clé.

Vérifiez votre compréhension

Tomás dit : « Journalisons chaque requête et chaque réponse au complet, au cas où. » Répondez-lui avec deux mesures de cette leçon.

Afficher la réponse

Avec la capture du texte sans caviardage, ops privacy a trouvé l’objet, le corps, la requête, la sortie du modèle et la réponse dans chaque billet. La commande a aussi trouvé deux fois l’adresse courriel du client. Chaque lecteur de Grafana et chaque copie des fichiers auraient les messages des clients, sans les règles de la base de données des billets. Cela a aussi augmenté la télémétrie de deux tiers : 21,6 Ko par billet au lieu de 12,9 Ko. Et ce n’était pas nécessaire : les résultats, les jetons, les raisons de fin et les durées répondaient à toutes les questions sur la semaine dernière.

Vérifiez votre compréhension

Prédisez : vous configurez TELEMETRY_SAMPLE=0.1. Qu'arrive-t-il aux SLI accept et draft, à la vue en cascade d'un billet aléatoire et au temps par requête de l'API?

Afficher la réponse

Les SLI ne changent pas : ils viennent des journaux et des métriques, qui comptent chaque billet. Un billet aléatoire a une probabilité d’environ 10 % d’avoir une trace. Pour les autres, ops waterfall affiche « No trace … it was not sampled » (aucune trace… elle n’a pas été échantillonnée). Le temps par requête de l’API reste à peu près le même : 3,66 ms avec toutes les traces, 3,75 ms avec 10 %. Elle écrit toujours ses événements, ses métriques et son propre segment de trace. Le processus retrouve l’essentiel de sa vitesse : 229 tâches par seconde au lieu de 201.

Vérifiez votre compréhension

Vérification pratique : exécutez ops privacy sur vos fichiers de télémétrie de la première leçon de ce module. Qu'affiche la commande, et pourquoi?

Afficher la réponse

python -m ops privacy telemetry/ticket-api.jsonl telemetry/ticket-worker.jsonl affiche la taille par signal et No text attribute, no e-mail address, no card number found. (aucun attribut textuel, aucune adresse courriel, aucun numéro de carte trouvé). Les paramètres par défaut n’ajoutent jamais le texte (TELEMETRY_CAPTURE_CONTENT=false), et le caviardage est activé comme protection de secours (TELEMETRY_REDACT=true). Dans l’exécution de l’auteur sur 5 billets, les fichiers occupaient 18,58 Ko par billet, surtout des segments de trace. Vos tailles seront légèrement différentes.

Exercice guidé : un billet qui a attendu 29 secondes

Section intitulée « Exercice guidé : un billet qui a attendu 29 secondes »

La dernière compétence de ce module consiste à trouver une étape lente et coûteuse dans une trace. Suivez d’abord un exemple détaillé où chaque étape est visible. Le fichier provient d’une exécution d’exercice d’un module ultérieur, avec le même service.

  1. Affichez la trace du billet échantillonné le plus lent :

    Fenêtre de terminal
    python -m ops waterfall data/telemetry/canary.jsonl.gz --slowest
    Trace 0193d235f0d3d4ec0dcc2ee84c1571bf, ticket T-501092 (the slowest of 2400 sampled): 33 spans, 29,239 ms from first to last
    span start ms ms cost US$
    POST /v1/tickets 0 14.7 #
    (waiting in the queue) 15 15.5 #
    process ticket job 30 10,027.4 ############
    triage ERROR 32 10,018.9 ############
    chat chat-small ERROR 32 10,018.3 ############
    POST ERROR 33 10,015.6 ############
    process ticket job 11,691 10,029.9 ############
    triage ERROR 11,698 10,016.8 ############
    chat chat-small ERROR 11,698 10,015.3 ############
    POST ERROR 11,698 10,013.6 ############
    process ticket job 24,980 4,259.2 #####
    triage 24,984 4,251.0 #####
    chat chat-small 24,984 4,248.0 ##### 0.000388
    POST 24,985 4,245.2 #####
    embed 29,235 2.5 #
    cache get 29,235 0.5 #
    (18 database queries hidden; --all shows them)
    Longest step: triage, 10,019 ms (34% of the trace)
    Costliest step: chat chat-small, US$0.000388 of US$0.000388: 1894 tokens in, 398 out (288 of them reasoning), finish stop
  2. Comptez les tentatives : trois segments de trace process ticket job (traiter la tâche du billet), donc la tâche s’est exécutée trois fois.

  3. Lisez les deux premières tentatives : chaque chat chat-small ERROR (erreur de conversation avec chat-small) dure 10,0 s, le délai d’expiration du fournisseur. Elles n’ont ni coût ni jetons : aucune réponse n’est revenue.

  4. Lisez les intervalles : la tentative 2 commence à 11 691 ms, soit 1,6 s après la fin de la tentative 1. La tentative 3 commence à 24 980 ms, soit 3,3 s après la tentative 2. Ce sont les attentes entre les nouvelles tentatives, et ops ne dessine aucune barre pour elles.

  5. Lisez la troisième tentative : une réponse normale en 4,25 s, à 0,000388 $ US, avec la raison de fin stop (arrêt).

  6. Additionnez : 20,0 s de délais expirés, 4,9 s d’attente entre les tentatives, 4,3 s de travail réel. Le goulot d’étranglement est l’expiration des délais, soit 69 % des 29,2 s. L’étape la plus coûteuse est le seul appel qui a fonctionné.

ops dit « Longest step : triage, 34 % » (étape la plus longue : triage, 34 %). C’est vrai pour un segment de trace, mais cela manque le motif : deux tentatives échouées de la même étape. Lisez toute la vue en cascade. Le message d’exercice du billet a plusieurs enregistrements, et la réexécution a choisi deux fois un enregistrement de plus de 10 s. C’est le problème d’expiration du délai présenté dans Qualité et coûts. Ici, il a retardé une réponse de 25 secondes.

À vous de jouer : trouvez l’étape lente et coûteuse

Section intitulée « À vous de jouer : trouvez l’étape lente et coûteuse »

Exécutez python -m ops waterfall data/telemetry/shadow.jsonl.gz --slowest. Ce fichier contient un autre exercice d’un module à venir. Trouvez l’étape la plus lente et la plus coûteuse. Dites ce que la trace prouve, ce qu’elle ne peut pas expliquer et quel signal fournirait le reste. N’utilisez pas le raisonnement du modèle : vous ne pouvez pas le lire.

Une solution détaillée

La sortie commence par Trace f265715a2074a667f3e7bc9a404b3fd5, ticket T-505297 (the slowest of 588 sampled): 26 spans, 67,073 ms from first to last (trace du billet T-505297, le plus lent des 588 échantillonnés : 26 segments de trace, 67 073 ms du premier au dernier) et se termine par :

Longest step: (waiting in the queue), 26,782 ms (40% of the trace)
Costliest step: chat chat-small, US$0.000388 of US$0.000388: 1894 tokens in, 398 out (288 of them reasoning), finish stop

Lisez-la comme dans l’exercice guidé :

Étape Début (ms) Durée Coût
Requête API 0 17 ms –
Attente dans la file 17 26,8 s –
Tentative 1 : chat chat-small ERROR (erreur) 26 803 10,0 s (délai dépassé) aucun coût enregistré
Intervalle avant la tentative 2 (attente avant nouvel essai, file) 36 821 26,0 s –
Tentative 2 : chat chat-small 62 802 4,25 s, fin stop (arrêt) 0,000388 $ US
embed (plongement) 67 060 8 ms (depuis le cache) –

Étape la plus lente : la file, 26,8 s, soit 40 % de la trace. L’intervalle avant la deuxième tentative correspond aussi à du temps dans la file. Le billet a donc attendu environ 53 secondes sur 67. Étape la plus coûteuse : le deuxième appel de triage, le seul appel avec un coût. Ici, l’étape lente et l’étape coûteuse sont différentes.

Ce que la trace prouve : le travail d’IA n’a pris qu’environ 14 s sur 67 s. Seulement 4,25 s de ce travail ont produit une réponse. La plupart du temps, le billet attendait un processus libre, pas le fournisseur.

Ce qu’elle ne peut pas expliquer : pourquoi la file était longue. Une trace montre un seul billet. Les jauges de la file les montrent tous. Dans le fichier, app.queue.depth indiquait 49 tâches en attente et 16 en cours à l’arrivée de ce billet. Cela occupait toutes les places des deux processus, soit 8 tâches chacun. Dans cet exercice, la plupart des tâches faisaient aussi un deuxième appel de triage pour un test d’un module à venir. Il s’agissait d’une exécution parallèle sans effet sur le service. Chaque tâche occupait donc sa place plus longtemps.

Quoi faire : la solution consiste à augmenter la capacité ou à réduire le travail par tâche (Amira), pas à modifier la requête.

Vérifiez votre compréhension

Vérification de fin : expliquez le goulot d'étranglement du billet T-503354 dans la reproduction de la semaine dernière, sans le raisonnement caché du modèle. Utilisez seulement ce que la trace montre.

Afficher la réponse

python -m ops waterfall data/telemetry/release-full.jsonl.gz --ticket T-503354 montre une trace de 9,2 s. L’API a pris 17 ms, et l’attente dans la file, 165 ms. L’appel de triage chat chat-small a pris 9 008 ms, soit 98 % de la trace. Il représentait tout le coût, soit 0,000650 $ US. Ses attributs expliquent pourquoi : 1 000 jetons en sortie, tous consacrés au raisonnement, et une fin length (limite de longueur). Le modèle a atteint la limite de jetons avant d’écrire la réponse. La tâche porte donc la mention ERROR (erreur) et n’a aucun plongement. Le texte du raisonnement est caché. Mais sa taille et sa durée figurent dans le segment de trace, et elles suffisent. Le goulot d’étranglement est la requête v3 avec cette limite de jetons, ce qui relève de Priya. L’API, la file, la base de données et le processus ne sont pas en cause.

Dans ce module, vous avez rendu le service de billets observable. Dans la première leçon, vous avez ajouté OpenTelemetry. Vous avez créé des événements aux noms fixes, des métriques pour chaque billet et une trace par billet traversant la file. Dans la deuxième, vous avez réparti les résultats, les catégories d’échec, les jetons et les coûts par version de requête. Vous avez aussi trouvé où passaient le temps et l’argent d’un billet. Dans cette leçon, vous avez exclu les mots des clients de toute cette télémétrie et mesuré le coût de chaque choix.

Le service peut maintenant répondre à quatre questions pour chaque billet et chaque version. A-t-il obtenu une réponse valide? Combien de temps cela a-t-il pris? Combien cela a-t-il coûté? En cas d’échec, de quelle façon a-t-il échoué?

Récapitulatif

  • Minimisez d’abord : décrivez un billet par sa longueur, sa langue estimée et son empreinte de hachage, jamais par son texte. TELEMETRY_CAPTURE_CONTENT reste à false (faux).
  • Le caviardage avant l’exportation supprime les attributs textuels et masque les adresses courriel et les numéros de carte. Capturer le texte, puis le caviarder ajoute seulement du risque.
  • L’échantillonnage conserve la trace d’une partie des billets; les journaux et les métriques comptent toujours chaque billet. Il a éliminé la majeure partie du coût de traçage du processus, mais aucun de celui de l’API.
  • La conservation (30 jours, ops prune) et le contrôle d’accès (Grafana Viewers, aucune copie des fichiers) limitent ce qui reste.

Prochain module : les entrées du service changent. La proportion de billets en français augmente, et les documents de la boutique changent. Vous vérifiez si les entrées ont dérivé et si cela signifie que l’assistant est devenu moins bon.

Leçon suivante : Dérive des données et dérive conceptuelle