Sommaire (8 parties)
J'administre un serveur partagé par une trentaine de membres. Chacun y fait tourner son propre rtorrent, un client BitTorrent en ligne de commande. Ce jeudi, j'ai traité un bug de production avec des agents IA, de la panne jusqu'au correctif.
Le bug d'abord. Après une mise à jour de rtorrent, des instances mouraient une à trois minutes après leur démarrage. Elles ne laissaient aucun message, aucun fichier de plantage, rien dans les journaux.
Le bug n'est pas le sujet de cet article, il en est la source. Le sujet, c'est la façon de travailler avec des agents sur une machine où d'autres gens ont leurs fichiers. Qui planifie, qui exécute, qui vérifie ? Comment prouver avant de toucher aux membres ? Où l'IA s'est trompée, où je me suis trompé, et ce qui a tranché à la fin.
Comment « propre » est devenu un plan
Avant la panne, il y a eu un plan, et ce plan est né d'une conversation. Pour la suivre, il faut d'abord savoir à qui je parlais.
J'ai fait ce travail avec Claude Code, l'outil d'Anthropic où une IA lance elle-même des commandes. Un agent, c'est une IA qui agit ainsi : elle exécute, lit le résultat, puis décide de la suite. La session principale, celle à qui je parle, peut lancer des sous-agents. Chacun reçoit un brief écrit, travaille à part et rend un rapport.
Ce jour-là, deux modèles se partageaient les rôles :
- Fable, le plus coûteux des deux, écrit les plans et mène les analyses difficiles.
- Sonnet exécute : il écrit le code et les tests d'après le plan. La session principale tournait aussi sur Sonnet.
Une instance, ici, c'est le rtorrent d'un membre, un processus à lui. Le serveur en fait tourner une trentaine, toutes sur le même programme, que je voulais passer de la version 0.9.8 à la 0.16.28. Ma consigne à l'IA tenait en une phrase : « le plus rapidement possible tout en faisant ça propre ».
« Propre » ne veut rien dire pour une machine. Plutôt que de foncer, l'IA m'a d'abord renvoyé des questions : combien d'instances, à qui elles appartiennent, ce qui ne doit surtout pas se perdre, et combien de temps un membre peut rester coupé.
Ces réponses-là, elle ne pouvait pas les lire dans le serveur. Les instances sont celles des membres, pas les miennes. Ce qui ne doit jamais arriver, c'est qu'un membre perde sa liste de torrents, ou que rtorrent revérifie tous ses fichiers, des heures de disque pour rien. Une coupure de quelques minutes, en revanche, personne ne la verra.
Elle a traduit ces réponses en mécanique. Une instance à la fois, pour qu'une erreur ne touche qu'un membre. Une sauvegarde avant chaque bascule, le moment où une instance passe à la nouvelle version. Un retour arrière prêt en une seule commande. Un script de contrôle après chaque bascule. Elle y a ajouté une idée que je n'avais pas : essayer le retour arrière une fois, à froid, avant d'en avoir besoin. Le partage était net. Je savais ce qui ne devait pas casser, elle savait comment le vérifier.
Une vingtaine d'instances sont passées ainsi, toutes au vert. Il restait pourtant une question que ni elle ni moi n'avions posée : au vert, mais pendant combien de temps ? Les instances ont répondu à notre place : certaines se sont mises à mourir, sans un mot.
Deux fausses pistes, puis une phrase têtue
Quand un programme meurt sans message, il n'y a rien à lire, alors on devine. L'IA a deviné deux fois. C'est une phrase sans aucune technique qui a ramené l'enquête sur des faits.
Première piste : mon régulateur de disque, un service maison qui ralentit les instances quand le disque n'arrive plus à suivre. L'IA a vérifié avant de conclure. Il n'avait rien appliqué à ce moment-là, donc la piste est tombée.
Deuxième piste : la session de connexion de mon compte, le groupe de programmes que le système rattache à ma connexion au serveur. Les instances encore en vie tournaient toutes dedans. Son idée : quand une session se ferme, le système emporte les programmes lancés depuis elle, et les instances mortes venaient d'une autre session, refermée entre-temps.
Cette fois, elle n'a pas vérifié. Elle avait pourtant écrit noir sur blanc « une hypothèse sérieuse, pas une certitude ». Elle a quand même relancé les instances mortes dans une session à part et corrigé le script de lancement en production. Une idée non vérifiée venait de modifier le serveur d'une trentaine de personnes. C'est là que j'ai tapé la phrase qui a tout changé :
« Il y a forcément un message d'erreur qui part quelque part, dans les journaux de rtorrent, du système ou ailleurs. Ça ne s'arrête pas sans rien dire. »
Cette phrase est une méthode, celle qu'un administrateur expérimenté applique sans y penser, et c'est pour remettre l'IA sur cette voie que je l'ai interrompue. Elle tient en trois temps :
- Un programme ne meurt jamais en silence. Il laisse toujours une trace : un message d'erreur, un code de sortie, un signal noté par le système.
- Si on ne voit rien, c'est notre façon de regarder qui est cassée. Avant toute théorie, il faut réparer l'observation.
- Les hypothèses viennent après le message, pas avant. Une coïncidence comme « les survivantes sont toutes dans ma session » reste une piste tant qu'aucune trace ne la confirme.
L'IA faisait l'inverse : elle partait des coïncidences pour bâtir une explication. Réorientée, elle s'est posé la bonne question : pourquoi ne voit-on rien ?
Tout programme a un canal réservé à ses messages de panne, la sortie d'erreur. Or les instances tournaient sous screen, un programme qui garde un terminal ouvert en arrière-plan, et screen avale ce canal. Le message existait, mais personne ne pouvait le lire.
Pour réparer l'observation, elle a relancé quatre instances sous systemd, le programme qui démarre et surveille les services du serveur. Avec systemd-run, chacune devient un service temporaire, et systemd note tout ce qu'elle dit dans son journal, sortie d'erreur comprise. Un peu plus d'une minute après, le journal donnait la phrase que screen cachait :
terminate called after throwing an instance of 'torrent::internal_error'
what(): PollInternal::modify(): epoll_ctl(DEL) error for event: name:curl_socket fd:69 : Bad file descriptor
rt-diag3-<membre>.service: Main process exited, code=killed, status=6/ABRT
Le message était enfin là. Restait à le comprendre.
Un bug hors de mon métier
Ce message, je n'y comprenais rien. Ce bug n'est pas mon métier : je développe des applications, je ne descends jamais jusqu'au noyau ni aux bibliothèques réseau. C'est l'IA qui m'a formé au problème. Le sous-agent d'analyse de la partie suivante a décortiqué le message, puis la session me l'a expliqué pas à pas. Voici cette explication, telle que j'ai fini par la comprendre.
Il faut trois notions, toutes posées sur le noyau, le cœur du système qui gère les fichiers et le réseau pour tous les programmes. Un descripteur est le numéro que le noyau donne à chaque fichier ou connexion réseau ouverte, ici le 69. epoll est une liste de surveillance tenue par le noyau. rtorrent y inscrit ses connexions pour être réveillé quand l'une d'elles a des données.
La troisième notion est libcurl, la bibliothèque qui parle HTTP pour rtorrent. Un tracker est le serveur qui met en relation ceux qui partagent un même fichier. rtorrent lui envoie régulièrement une annonce, un message qui dit « je partage ce fichier, qui d'autre ? », en HTTP, par libcurl. Pour garder sa liste epoll exacte, rtorrent demande à libcurl de le prévenir à chaque fermeture. Il lui confie pour ça sa propre fonction de fermeture, prévue par l'option CURLOPT_CLOSESOCKETFUNCTION. libcurl doit l'appeler à chaque fois qu'elle ferme une connexion.
Le déclencheur est un tracker mort, qui ne répond même pas au SYN, le premier paquet d'une connexion, l'équivalent d'un « bonjour ». Voici la chaîne, dans l'ordre :
rtorrent, lui, ne fait rien de travers. Il croit ce que la documentation de libcurl lui promet : être prévenu de chaque fermeture. Et son code refuse toute erreur d'epoll, parce qu'il préfère s'arrêter plutôt que de continuer avec une liste fausse. Le plantage tombe 60 secondes après l'annonce, le temps que libcurl abandonne : ce délai est fixé dans le code de rtorrent.
Une instance dont tous les trackers répondent ne plante donc jamais. Le mystère du début s'éclairait enfin : certaines instances tenaient, d'autres non, selon leurs trackers. Celle qui m'a servi de cobaye plus tard en avait six morts.
Avec ce mécanisme en tête, je pouvais enfin suivre la discussion. L'IA ne m'a pas donné une solution. Elle m'a mis quatre options sur la table, avec ce que chacune coûte :
- Revenir à l'ancienne version, la 0.9.8. Sûr et immédiat, mais on renonce à la mise à jour.
- Régler le noyau pour qu'il abandonne plus vite les connexions sans réponse (
tcp_syn_retries). Aucun code à écrire, mais rien ne garantit que ça suffise. - Recompiler libcurl avec la ligne que les auteurs de curl ont déjà corrigée. Ça soigne la cause, mais ça touche une bibliothèque dont dépend tout le système.
- Corriger libtorrent, la bibliothèque de rtorrent, pour qu'elle encaisse la fermeture en douce de l'étape ③. Le changement reste limité à rtorrent, et on le retire le jour où Debian, le système du serveur, livrera une libcurl corrigée. C'était sa recommandation.
Je n'avais pas besoin de devenir expert d'epoll. Il me fallait comprendre assez pour juger ce que chaque option touche, ce qu'elle risque et comment on revient en arrière. Ça, l'IA me l'a appris en une conversation. J'ai choisi de corriger libtorrent. C'était sa recommandation, mais le choix était le mien, fait en connaissance de cause, et à une condition : que le correctif soit prouvé avant de toucher aux instances des membres.
Restait à prouver deux choses : que l'explication était juste, et que le correctif tenait.
Chercher dans le code, puis le prouver
Cette explication et ces options ne sont pas tombées du ciel. Elles sortent d'une seule demande, tapée dès que j'ai eu le message d'erreur :
« Va chercher sur internet et dans le code source ce qui se passe, et analyse avec Fable. »
La session en a tiré un brief de quatre points pour un sous-agent Fable : lire le code, chercher chez les auteurs de curl et de rtorrent, écrire un correctif, le prouver sur un banc isolé. Il travaillait dans un dossier à part, loin des instances des membres. Moins d'une heure plus tard, son rapport disait trois choses : ce qu'il avait trouvé, ce qu'il avait prouvé, et ce qu'il n'avait pas prouvé.
Ce qu'il a trouvé
Le bug vient de libcurl, et il est connu. Les auteurs de curl l'ont corrigé d'une ligne en juillet 2023 (PR #11439, livrée dans curl 8.2.0). Mais Debian 12 livre encore une libcurl d'avant ce correctif, la 7.88.1. Côté rtorrent, un ticket ouvert rapporte notre message exact, sans que personne en ait trouvé la cause.
Le rapport listait aussi ce qu'il n'avait pas trouvé : aucune version plus récente de rtorrent qui règle le problème, aucun correctif publié, aucune option de configuration. Cette liste vaut autant que la cause, parce qu'elle m'évite de chercher une option miracle qui n'existe pas.
Ce qu'il a prouvé
Une explication convaincante ne suffisait pas : la session venait d'en donner une fausse. Le banc d'essai reproduisait donc le piège en petit, sur un réseau privé : un faux tracker dont deux adresses ne répondent jamais, et 300 torrents factices qui l'appellent toutes les 15 secondes. Chaque essai y répond à une seule question :
| Essai | La question | Résultat |
|---|---|---|
| rtorrent d'origine | Le bug se reproduit-il ? | 8 plantages sur 8, avec le message de la production |
| rtorrent corrigé (option libtorrent) | Le correctif tient-il ? | 30 min 36 s sans erreur, 30 397 annonces |
| rtorrent d'origine, libcurl corrigée d'une ligne | La cause est-elle la bonne ? | 16 min sans plantage |
rtorrent d'origine, noyau réglé (tcp_syn_retries=3) | Le réglage suffit-il ? | 3 plantages sur 3 |
La troisième ligne est la plus importante. Elle ne teste pas le correctif, elle teste la cause : rtorrent inchangé, une seule ligne de libcurl changée, et le plantage disparaît. La quatrième ferme la porte au réglage du noyau, l'option qui ne demandait aucun code.
Le correctif choisi tient en une centaine de lignes. libtorrent note chaque connexion qu'il confie à libcurl. Si libcurl l'a fermée en douce, il l'oublie au lieu de planter, et garde son contrôle strict pour tout le reste.
Ce qu'il n'a pas prouvé
Le rapport finissait par ses propres limites. Je les recopie, parce qu'elles disent jusqu'où on peut lui faire confiance :
- aucun essai avec de vrais trackers ni de vrais pairs ;
- une des protections du correctif n'a jamais servi pendant les essais ;
- une demi-heure de tenue, pas des jours.
Le rapport traçait donc la frontière : prouvé sur un banc, pas encore en production. Il fallait passer en production sans parier tout le serveur.
Un cobaye avant tout le monde
Le banc prouvait le correctif en petit. Pour la production, on a repris la règle de la mise à jour : une instance à la fois, et un retour arrière immédiat. Une simple liste décide quelles instances partent sur la version corrigée, et en retirer une ligne suffit à revenir en arrière.
La première inscrite était un cobaye choisi exprès : l'instance aux six trackers morts, la plus exposée au bug. Ma règle : les autres ne passent sur la version corrigée que si celle-là tient. Au moment où j'écris, le jeudi 19 novembre à 12 h 32, elle tourne depuis plus de dix minutes, bien au-delà des 60 à 90 secondes où elle mourait. Le reste attend.
Cette fois, la question oubliée au départ, au vert mais pendant combien de temps, avait sa réponse : dix minutes, sur l'instance la plus exposée, avant de toucher aux autres. Il aurait fallu la poser dès la mise à jour.
La consigne que j'aurais dû donner
Avec le recul, notre « propre » avait trois trous. Le bug n'y est pour rien : on pouvait les boucher avant de lancer quoi que ce soit.
- « Propre » ne disait pas à quoi on reconnaît une instance qui marche. Nous avions défini ce qui ne devait pas se perdre, rien de plus. Le contrôle a pris le critère le plus simple, la liste de torrents relue au démarrage. Or le bug tue une à trois minutes plus tard, donc son feu vert ne prouvait rien.
- Rien ne disait quand s'arrêter. « Le plus rapidement possible » ne demandait ni d'attendre entre deux bascules, ni de s'arrêter à la première instance morte.
- Rien ne disait comment voir. Sous
screen, une instance morte ne laissait aucune trace.
Le plan corrigé tient en quelques lignes de plus :
« Passe d'abord une seule instance, la plus exposée : beaucoup de torrents, beaucoup de trackers. Lance-la sous systemd pour garder sa sortie d'erreur. Elle est passée proprement si elle tourne encore au bout de dix minutes et que son journal ne contient aucune erreur. Seulement alors, passe les autres par petits lots, avec le même contrôle. À la première instance morte, arrête tout et remets l'ancienne version. »
Chaque trou a maintenant sa réponse. « Propre » a un critère que l'IA peut vérifier seule : dix minutes sans erreur dans le journal. L'arrêt est écrit : à la première instance morte, on revient en arrière. Et systemd garde la sortie d'erreur, donc on voit pourquoi une instance meurt.
Avec cette consigne, une seule instance serait morte, et son message d'erreur aurait été là dès ce premier plantage. Ralentir sur la première instance aurait été le chemin le plus rapide.
Conclusion
Ce n'est pas la technique qui a trouvé la cause. C'est une phrase d'administrateur, « ça ne s'arrête pas sans rien dire », et systemd, qui a gardé la sortie d'erreur. Dès que l'IA a eu ce message, un fait au lieu d'une idée, elle a fait tout le reste, vite et bien.
Avant ce message, elle devinait. C'est là qu'elle est dangereuse, parce qu'elle devine avec la même voix calme que lorsqu'elle sait : son « hypothèse sérieuse, pas une certitude » avait déjà modifié un script de production. Là où se tromper coûte peu, en revanche, elle excelle : lire du code inconnu, fouiller un ticket, monter un banc.
Mon travail n'était donc pas de taper les commandes. C'était de refuser l'explication qui ne collait pas, d'exiger le message d'erreur, de choisir le correctif en connaissance de cause, puis d'exiger la preuve avant de déployer. Cette partie ne se voit pas dans le résultat, j'en parlais déjà dans « C'est l'IA qui l'a fait ».
Et la preuve vaut plus que le correctif. Le correctif sera jeté le jour où Debian livrera une libcurl corrigée. La preuve, elle, reste : une seule ligne changée dans libcurl, et le plantage disparaît. Une explication, même juste, se discute. Un essai qui passe du rouge au vert, non.
Sources
Documentation consultée le 19 novembre 2026 :
- curl PR #11439, « cf-socket: don't bypass fclosesocket callback if cancelled before connect » : le correctif d'une ligne, livré dans curl 8.2.0.
- Journal des versions de curl : la ligne du correctif dans la liste de 8.2.0, publiée le 19 juillet 2023.
- rakshasa/rtorrent #2090 : le ticket rtorrent ouvert, avec le même message sous Debian 12.
- CURLOPT_CLOSESOCKETFUNCTION : la fonction de fermeture que libcurl doit appeler.
- epoll_ctl(2) : l'appel qui renvoie
EBADFsur un descripteur fermé. - systemd-run(1) : lancer un programme comme service transitoire, avec sa sortie dans le journal.
- libcurl4 dans Debian 12 : la version livrée, 7.88.1-10+deb12u15.