Suivre l’exécution d’un processus

Objectif

Voir ce que votre processus a réellement fait : chacune de ses exécutions et — pour n’importe laquelle — chaque étape franchie, dans l’ordre, avec la raison de son arrêt le cas échéant.

Prérequis

• Le processus est publié. Un brouillon ne s’est jamais exécuté.
• Vous êtes créateur dans l’environnement.

Où cela se trouve

Ouvrez le processus et sélectionnez Exécutions dans le rail, à côté de Flux et de Formulaires de décision. C’est la seule entrée qui ne soit pas quelque chose que vous modifiez : les deux autres sont le processus, celle-ci est son historique.

La liste

Chaque exécution, la plus récente en premier — l’inverse de votre liste de tâches, et c’est voulu : une file se traite de la plus ancienne à la plus récente parce que la plus ancienne a attendu le plus longtemps, mais quelqu’un qui ouvre une liste d’exécutions s’intéresse presque toujours à celle qui vient de se produire.

Chaque ligne indique quand elle a démarré, si elle est En cours, Terminée ou Annulée, la version sur laquelle elle a démarré, et En attente de.

« En attente de » est la colonne à lire

Elle nomme les personnes chez qui se trouve encore l’exécution. C’est ce qui distingue une exécution saine d’une exécution bloquée :

• Des noms — l’exécution attend ces personnes, ce qui est normal et n’est pas un problème. Une étape proposée à tous les détenteurs d’un rôle nomme les trois premiers puis indique combien d’autres ; une étape qu’une personne a déjà prise nomme cette personne.
• Personne, sur une exécution toujours marquée En cours — c’est celle-là qu’il faut regarder. Rien n’attend une personne et elle n’est pas terminée : elle s’est donc arrêtée quelque part. Ouvrez-la.

Elle affiche aussi Personne quand une étape est ouverte mais que son attribution n’a abouti à personne — une tâche qui existe et ne figure dans la liste de personne. C’est la même chose à aller regarder, et l’historique indique quelle étape et pourquoi.

remarque

Un nom que vous ne reconnaissez pas, ou quelque chose comme systemuser:9f3c…, signifie que l’environnement n’a pas pu identifier cette personne — généralement un utilisateur supprimé depuis la création de la tâche.

Qui la retient

Sous le schéma, une exécution qui a encore quelque chose d’ouvert liste En attente de : une ligne par étape qu’elle n’a pas franchie, avec les personnes chez qui elle se trouve, le moment où l’attente a commencé, depuis combien de temps elle attend, et son échéance.

C’est la réponse à la question avec laquelle on ouvre généralement une exécution arrêtée. L’historique dit ce qui s’est déjà passé et le schéma dit jusqu’où l’exécution est arrivée ; aucun des deux ne dit qui doit agir ensuite.

Vous ne pouvez pas effectuer ces tâches ici, et c’est voulu. Il s’agit de la vue du créateur sur la mécanique, et elle ne s’exécute pas avec les autorisations de la personne à qui la tâche est destinée. Le travail se fait dans le Shell de la plateforme : ouvrez l’application, puis le bac des tâches dans la barre supérieure.

Confier une tâche à quelqu’un d’autre

Il y a une chose que vous pouvez faire à une tâche depuis ici : Transmettre, sur la ligne.

Utilisez-le quand la personne qui a la tâche ne peut pas la faire — elle est partie, elle est absente, le travail a été orienté vers le mauvais groupe. Sélectionnez Transmettre, choisissez quelqu’un et confirmez. La tâche quitte la personne qui l’avait et est proposée à celle que vous avez désignée ; celle-ci la prend en l’ouvrant, exactement comme n’importe quelle autre tâche.

C’est un pouvoir différent de celui du Shell de la plateforme, et il vaut la peine de savoir lequel vous utilisez. Le bouton Transmettre de la liste de tâches d’une personne ne peut être utilisé que par la personne qui détient la tâche — il répond à « je m’absente ». Celui-ci est le vôtre parce que vous pouvez ouvrir cet écran, et il répond à « quelqu’un s’est absenté ». Dans les deux cas, la tâche doit être encore ouverte : une décision déjà prise ne peut pas être transmise.

L’exécution, étape par étape — sur un schéma

Sélectionnez une exécution et, au-dessus de son historique, vous obtenez l’exécution dessinée.

Ce n’est pas votre schéma avec l’étape en cours mise en surbrillance, et cette différence est essentielle. Une exécution passe par une étape autant de fois qu’elle le veut : un rejet qui renvoie le travail en arrière passe trois fois par la même étape, et la mettre en surbrillance vous montre une boîte visitée — pas les trois passages, ni leur ordre, ni celui que vous regardez.

L’exécution est donc déroulée. Une forme pour chaque étape franchie, disposées de gauche à droite dans l’ordre où elles se sont produites, avec vos propres formes et vos propres couloirs :

• Une étape atteinte deux fois apparaît deux fois, et la seconde indique passage 2. Le troisième passage est la troisième colonne : une boucle se lit donc vers l’avant plutôt que comme une flèche qui revient en arrière.
• Les chemins d’une division sont des lignes parallèles, chacun restant sur sa propre ligne tant qu’il existe, et la jonction les ramène tous vers l’étape où le processus continue.
• Là où se trouve l’exécution maintenant est entouré en ambre et indique ici maintenant. Là où un chemin s’est arrêté est entouré en rouge et indique arrêté ici.
• Les couloirs sont les vôtres. Une bande par couloir, pas une par passage — un couloir est une personne, et deux bandes « Responsable » feraient deux lignes pour une seule d’entre elles.

L’historique lui-même comporte cinq colonnes : quand c’est arrivé, ce qui est arrivé, l’étape où cela s’est produit, le type de cette étape, et tout détail que porte l’événement — la connexion prise par un branchement, une échéance dépassée, la raison de l’arrêt d’un jeton.

La colonne de l’étape affiche le nom de l’étape, celui que vous lui avez donné dans le concepteur. Elle affichait autrefois l’identifiant généré par le concepteur — n-start, n-3 — qui ne disait rien à personne. Une étape que le processus ne contient plus affiche toujours son identifiant, car c’est la seule chose vraie qui reste à son sujet.

Cliquez sur une forme et l’historique en dessous se restreint à cette étape : ce que le moteur a fait pendant que le processus s’y trouvait, et rien d’autre. Afficher toute l’exécution rétablit l’ensemble.

Il est dessiné d’après la version en cours d’exécution

Une exécution se termine sur la version sur laquelle elle a démarré, même si vous avez publié deux fois depuis. Le schéma suit l’exécution, pas le brouillon actuel — ce que vous regardez est donc ce qui s’est réellement exécuté. Si cette version n’est plus stockée, le schéma n’est pas dessiné et l’historique s’affiche seul.

Ce qui s’est passé, étape par étape

L’historique apparaît dans l’ordre où les choses se sont produites :

Vous verrez	Ce que cela signifie
Exécution démarrée / Exécution terminée	L’instance elle-même
Atteinte	Le processus est arrivé à cette étape
Branchement	Un branchement a choisi une sortie, et quelle connexion il a prise
Division / Jonction	Une division a créé plusieurs chemins à la fois, et une jonction les a réunis
Tâche créée / Tâche terminée	Du travail est allé à une personne, puis est revenu
Chemin terminé / Chemin annulé	Un chemin s’est terminé — un processus avec une division en a plusieurs
Arrêtée	Celle qui compte : le processus n’a pas pu continuer, et la raison est écrite en toutes lettres

Arrêtée est la raison d’être de cet écran. Un processus qui s’arrête — un branchement où aucune condition n’était vraie, un script qui ne s’analysait pas, une tâche qui n’a pu être attribuée à personne, une issue sans connexion sortante — enregistre exactement ce qui n’allait pas au moment où cela s’est produit. Cette phrase est la réponse à « pourquoi rien ne s’est passé ? ».

Une très longue exécution

Une exécution qui a bouclé des milliers de fois a plus d’historique que l’écran n’en affiche. Dans ce cas, il le dit : les premières étapes sont listées et les autres non. Il ne vous montre jamais discrètement les premières comme si elles étaient toute l’histoire.

Une exécution avec de très nombreux chemins

Une exécution qui s’est divisée plus de fois que le schéma ne peut en dessiner le signale au-dessus : certaines branches manquent sur l’image. L’historique en dessous n’est pas affecté — c’est de toute façon l’enregistrement complet.

Prendre la main sur une exécution

Observer n’est pas la seule chose que fait cet écran. Le long de la barre de titre se trouvent les commandes qu’offre une exécution encore en cours — une exécution terminée n’en offre aucune, car il ne reste rien à retenir, à relâcher ou à arrêter.

Suspendre

Suspendre retient l’exécution. Chaque chemin, chaque tâche et chaque échéance restent exactement où ils sont, et rien ne bouge jusqu’à ce que vous la repreniez. L’exécution affiche Suspendue plutôt qu’annulée, ce qui compte : une exécution suspendue est vivante, et quelqu’un qui lirait « annulée » irait redémarrer le processus.

Utilisez-le quand une exécution fait quelque chose que vous n’aviez pas prévu et que vous avez besoin d’un moment pour l’examiner — auparavant, le seul moyen d’empêcher une exécution de mal faire était de l’annuler, ce qui est irréversible.

Reprendre

Reprendre la relance, exactement là où elle s’était arrêtée.

Une chose à prévoir : un minuteur arrivé à échéance pendant la suspension se déclenche immédiatement. Le moment est passé, et l’exécution ne le récupère pas — une étape qui attendait jusqu’à vendredi et qui est reprise le lundi avance le lundi.

Arrêter

Arrêter met fin à l’exécution pour de bon. Chaque chemin s’arrête là où il se trouve, et les tâches qu’elle avait déposées dans les boîtes de réception sont retirées — personne ne reste avec une décision entre les mains sans processus derrière elle. Le gestionnaire À l’annulation du processus s’exécute, et c’est le seul moment où il s’exécute.

Une confirmation vous est demandée, ainsi que la raison. Celle-ci est facultative — « arrête-la » est une instruction complète — mais elle est inscrite dans l’historique, là où regardera la prochaine personne à se demander « qu’est-il arrivé à celle-ci ? ».

Une exécution arrêtée ne peut pas être redémarrée d’ici. Démarrez plutôt le processus à nouveau.

Un chemin arrêté, et le réessayer

Quand un chemin n’a pas pu franchir son étape, l’exécution affiche un panneau Chemins arrêtés au-dessus des tâches ouvertes : une ligne par chemin, nommant l’étape où il s’est arrêté, avec Réessayer à côté.

L’historique dit pourquoi il s’est arrêté — un branchement où aucune condition n’était vraie, un script qui ne s’analysait pas, un enregistrement absent. Corrigez d’abord cette cause ; ensuite, Réessayer replace le chemin sur l’étape et la retente.

Deux choses à savoir :

• Il exécute la version de l’exécution, comme toute autre étape. Republier le processus ne change pas ce qu’exécute une exécution déjà en cours : un défaut dans le dessin ne se corrige donc pas en republiant puis en réessayant — cette exécution continuera d’échouer de la même façon. Réessayer sert pour une cause qui a disparu depuis : un enregistrement manquant, un service indisponible, un réglage que personne n’avait renseigné.
• Uniquement sur une exécution encore en cours. Les chemins d’une exécution arrêtée ne se voient pas proposer de nouvelle tentative : en relancer un reviendrait à relancer un processus que quelqu’un a délibérément arrêté.

Faire passer une exécution sur une nouvelle version

C’est impossible, et c’est voulu. Une exécution se termine sur la version sur laquelle elle a démarré. Il n’y a aucun moyen d’en faire passer une sur un dessin plus récent, car les deux documents n’ont pas forcément les mêmes étapes — l’exécution se trouve sur une étape que la nouvelle version a peut-être renommée, déplacée dans un autre couloir ou supprimée, et aucune règle que la plateforme pourrait écrire ne devinerait juste à coup sûr.

Que faire à la place : publiez la nouvelle version, pour que chaque exécution démarrée à partir de maintenant l’utilise, et laissez se terminer celles déjà en cours. Là où une exécution en cours doit vraiment suivre le nouveau schéma, arrêtez-la, dites pourquoi, et démarrez-en une nouvelle.