Aller au contenu
Blogue Krizaka

19

Tchou-tchou : comment nos pull requests prennent le train

28–30 oct. 20269 min de lecture

Ce que j'ai affronté, 140 PR ouvertes et des sessions qui attendaient la CI; Ce qu'on a construit, des trains qui déposent, 5 PR par dépôt au plus, une garde par panne

Un canal à l'aube, à l'aquarelle, sous un soleil pâle : des maisons de brique à gauche, des réverbères le long du quai à droite, et un petit train qui traverse le pont de pierre, reflété dans l'eau immobile

Cette semaine, j'ai compris que mes agents ne manquaient pas de vitesse. Ils manquaient de quai. Chaque session finissait son travail, ouvrait une pull request, puis attendait que la CI passe, que la merge queue l'accepte, que la branche soit à jour. Pendant ce temps, la session coûtait, et la pile grossissait.

Ce chapitre raconte le petit système qui a remis ça en mouvement. Je l'appelle le train, parce que c'est exactement ça : des wagons qui partent l'un derrière l'autre, sans se doubler.

Le problème : une pile

Nous travaillons avec cinq lanes : une session par application (Yomizaka, Akinaza, Orazaka), une pour la plateforme, une pour la sécurité. Chacune ouvre ses PR. En fin de journée jeudi, il y avait une centaine de PR ouvertes dans l'organisation. Vendredi à 2 h du matin, il y en avait 140, et une heure plus tard le dépôt d'Akinaza en portait 24 à lui seul.

Le goulot n'était pas le code. C'était la capacité de la CI et de la merge queue : une PR doit passer, une autre attend derrière, et si la branche change entre-temps, tout recommence. Une session qui attend, c'est une session qui brûle du budget pour regarder un cercle tourner.

Le train

Le train est un petit script : moins de quatre-vingts lignes de shell, sans aucun token de modèle. Il prend des PR déjà relues, dans l'ordre, et pour chacune :

  1. AttendreLa PR précédente est fusionnée. Pas avant.
  2. Mettre à jourLa branche rattrape main. Si GitHub a changé sa base, elle suit.
  3. ApprouverUne seule fois par version de la branche, avec mon compte.
  4. Mettre en fileLa PR entre dans la merge queue.
  5. S'arrêter au premier rougeUn check rouge, un conflit, une éjection : le train s'arrête et dit pourquoi. Il ne fusionne jamais autour d'un échec.

Le point important : la relecture se fait avant, par la session qui a écrit la PR, pas par le train. Le train ne juge rien. Il fait le travail de quai, celui qu'un agent fait mal parce qu'il coûte cher de l'attendre.

Le trajet d'une pull request, de sa branche à la production : la session écrit et relit, le train ne fait que porter.
  1. Branche (une session)Un worktree depuis main, une issue, le test d'abord. La session relit son propre diff avant d'ouvrir la PR.
  2. Checks (CI sur la PR)Lint, tests, build, analyse du code. Un check rouge arrête tout ici.
  3. Le train (aucun token)Il attend la PR précédente, met la branche à jour, approuve une fois par version, met en file. Il s'arrête au premier rouge.
  4. Merge queue (CI encore)Les checks repassent, sur la PR fusionnée avec ce qui la précède dans la file.
  5. main (un commit)La PR devient un seul commit sur main, et sa branche est supprimée.
  6. Déploiement (puis vérifié)Le site est construit et déployé ; un job vérifie ensuite que le site en ligne porte bien ce commit.

Ce qui a cassé, et la garde qui en est sortie

Le train n'a pas marché du premier coup. Chaque panne est devenue une règle, et chaque règle a son test.

  • doublons

    Ce qui s'est passé
    Le même train lancé quatre fois par des sessions différentes.
    La garde
    Un seul train par PR Le script refuse de démarrer si un train vivant porte déjà cette PR.
  • approbations

    Ce qui s'est passé
    Une approbation toutes les 90 secondes : GitHub nous a limités.
    La garde
    Approuver une fois par version Le train retient la version déjà approuvée.
  • éjection

    Ce qui s'est passé
    Une PR éjectée de la file a été remise en file sept fois.
    La garde
    S'arrêter à la première éjection Une éjection est un signal, pas un incident à rejouer.
  • quota

    Ce qui s'est passé
    Vingt-sept trains qui interrogeaient l'API toutes les 90 secondes ont vidé le quota partagé.
    La garde
    REST, toutes les 3 minutes Les lectures passent par l'API REST ; seule la mise en file reste une mutation.
  • silence

    Ce qui s'est passé
    Une réécriture du script a fait tourner tous les trains à vide pendant une heure, sans erreur.
    La garde
    Un test des fonctions de lecture L'état d'une PR est maintenant testé avant chaque changement du script.
  • bot de versions

    Ce qui s'est passé
    Un bot ouvrait une PR de mise à jour par fusion : 116 doublons.
    La garde
    Une PR de versions par dépôt Une règle d'organisation s'ajoute à la PR de masse ouverte, elle n'en ouvre pas une autre.
  • délai

    Ce qui s'est passé
    Le délai de la merge queue était plus court que la CI : des éjections à tort.
    La garde
    Un délai plus long que la CI La file ne juge plus une CI saine trop lente.
  • check sauté

    Ce qui s'est passé
    Le nom d'un job sauté n'était pas évalué : une PR restait bloquée sur un check fantôme.
    La garde
    Des noms littéraux Les checks requis portent leur nom exact.

Chaque ligne de ce tableau est un incident réel de cette semaine. Je les garde ensemble parce que c'est leur forme commune qui compte : une panne n'est pas finie quand elle est réparée, elle est finie quand elle ne peut plus revenir sans qu'un test devienne rouge.

Les règles qui en sont sorties

Le train a aussi changé nos règles de travail, qui comptent plus que le script :

  • Au plus 5 PR ouvertes par dépôt. À la limite, personne n'en ouvre une nouvelle : on fusionne d'abord.
  • Finir avant de commencer. La première tâche d'une session, ce sont ses PR ouvertes, les plus anciennes d'abord : les faire passer, ou les fermer en disant pourquoi.
  • Une seule PR de masse par dépôt à la fois. Une nouvelle règle d'organisation rejoint la PR de masse ouverte au lieu d'en ouvrir une autre.
  • Un ordre de fusion. On empile deux PR seulement quand la première est déjà dans la file.

Une règle qui vit dans un document s'oublie, alors chacune est devenue une garde qui refuse, avec son test :

  1. CommitPas de ligne de co-auteurUn commit ou une description de PR qui nomme une IA comme co-auteur est refusé avant de quitter la machine : notre application est le seul auteur.
  2. OuvrirCinq PR par dépôtOuvrir une sixième est refusé, bots de versions compris. À la limite, on fusionne d'abord.
  3. RondePas d'orphelineUn script liste les PR ouvertes qu'aucun train ne porte : verte, elle reçoit un train ; rouge, elle retourne à sa lane, nommée.
  4. RougeUn rouge périmé est rafraîchi une foisUn rouge sur une branche en retard sur main est souvent déjà corrigé là-bas : le train met la branche à jour une fois, puis juge le nouveau passage.
Ce qui arrête un train, ou ne le laisse jamais partir : quatre gardes écrites cette semaine, chacune avec son test.

Une pile de PR ouvertes me dit une chose : l'ordre du travail était mauvais. Le train soulage le symptôme, la règle des cinq soigne la cause.

Ce que ça change

Les chiffres que je peux donner sont ceux que je peux relire. Je les ai comptés depuis l'API de GitHub : pour chaque heure, toutes les pull requests de l'organisation créées avant et pas encore fermées. Le dépôt d'Akinaza est passé de 24 PR ouvertes vendredi à 3 h du matin à 4 en soirée. Dans l'organisation, la pile est passée de 140 à 50 au moment où j'écris ces lignes, et 317 PR ont été fusionnées dans la journée de vendredi.

Les pull requests ouvertes dans l'organisation, toutes les six heures du jeudi matin au vendredi soir : la pile culmine à 140, puis les trains la font descendre.

Compté depuis l'API de GitHub le 30 octobre : les pull requests créées avant chaque heure et pas encore fermées, dans les dépôts que l'organisation garde aujourd'hui ; heure de Montréal.

Graphique en barres, 8 (Jeu. 8 h – Ven. 22 h 30). PR ouvertes : de 119 à 50, minimum 50 (Ven. 22 h 30), maximum 140 (Ven. 2 h), en baisse de 58 %.

Les pull requests ouvertes dans l'organisation, toutes les six heures du jeudi matin au vendredi soir : la pile culmine à 140, puis les trains la font descendre. — données
ÉlémentPR ouvertes
Jeu. 8 h119
Jeu. 14 h89
Jeu. 20 h107
Ven. 2 h140
Ven. 8 h77
Ven. 14 h66
Ven. 20 h66
Ven. 22 h 3050
Les pull requests ouvertes dans l'organisation, toutes les six heures du jeudi matin au vendredi soir : la pile culmine à 140, puis les trains la font descendre.

Le pic de la nuit n'a rien de mystérieux : c'est le moment où les sessions finissent leur travail et ouvrent leurs PR, pendant que les trains attendent encore la CI. La baisse du matin, ce sont les trains, qui fusionnent une PR après l'autre.

Je ne donne pas de « temps gagné » : je ne l'ai pas mesuré, et je préfère me taire que d'inventer un chiffre. Ce que je vois, c'est que les sessions ne passent plus leur temps à attendre, et qu'on a arrêté de se marcher dessus.

Ce qui reste

Le train dépend de la CI, et la CI reste lente : le chapitre suivant raconte comment elle a grandi, et comment on l'a mesurée. Le plafond de 5 PR par dépôt est une règle qu'un humain ou un agent peut oublier : nous la vérifions encore à la main à chaque point de contrôle. Et quand le quota de l'API est vide, tout s'arrête, ce qui s'est déjà produit une fois.

Ma devise, et le mode économie

Cette semaine, j'ai aussi posé une phrase en tête de toutes les règles de nos agents : « Le flux tourne, l'échéance est à nous : elle peut bouger, la qualité jamais. » Le flux, ce sont les trains et les petites PR. L'échéance, c'est nous qui la fixons, et nous disons quand elle bouge. La qualité, on ne la rogne pas pour tenir une date : pas de hook sauté, pas de test affaibli, pas de rendu « assez bien ».

Quand mon usage de Claude a atteint 75 % de la semaine, vendredi, nous sommes passés en mode économie : deux sessions au plus, un modèle moins coûteux pour les tâches de dépôt, pas de rendu payant. Les trains, eux, ont continué à travailler sans consommer un token de modèle. Le mode économie a duré quelques heures, puis j'ai décidé de continuer. C'était mon choix, et mon budget.

Questions fréquentes

Un train remplace-t-il la relecture ?

Non. La relecture se fait avant, par la session qui écrit la PR. Le train ne juge pas le code : il attend, met à jour, approuve et met en file.

Pourquoi pas la fusion automatique de GitHub ?

Nous l'utilisons aussi. Le train couvre ce qu'elle ne fait pas : attendre la PR précédente, remettre la branche à jour après un changement de base, et s'arrêter au premier problème en le disant.

Pourquoi 5 PR par dépôt ?

Parce que 24 PR ouvertes sur un dépôt, c'est 24 branches qui se rebasent les unes sur les autres. Cinq, c'est ce qu'on arrive à fusionner dans une journée.

Chapitre 19

Résultats

PR ouvertes dans l'organisation au plus fort de la pile, vendredi à 2 h

140

Le problème : une pile

PR ouvertes sur le dépôt le plus chargé, avant et après

24 → 4

Ce que ça change

PR de mise à jour de versions fermées comme doublons

116

Ce qui a cassé, et la garde qui en est sortie