Forcer le redémarrage d’un worker Symfony

Il arrive de temps en temps que notre worker n’arrive pas à se relever. Aussi fort que vous vous battez, l’erreur a mis PHP ou votre application dans un état instable et il n’y a rien à faire à part l’achever !

Pour pallier ça, vous avez deux options !

Si vous avez la main sur l’exception qui est levée, vous pouvez implémenter StopWorkerExceptionInterface ou lever directement une instance de StopWorker. Symfony laissera alors le worker s’éteindre après le traitement du message.

Cependant, il y a des cas où vous n’avez pas la main sur l’exception. Prenons l’exemple de « RedisException ». Si la connexion entre PHP et Redis est instable, les appels vers Redis échoueront. Et même si la connexion revient à la normale, un certain nombre d’appels seront toujours en échec. Il est possible de wrapper tous les appels à Redis. Mais… c’est long et fastidieux.

À la place, nous vous proposons ce listener, qui permettra d’éteindre le worker, si une exception d’un certain type est levée :

namespace App\Messenger\Listener;

use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\Messenger\Event\WorkerMessageFailedEvent;
use Symfony\Component\Messenger\Event\WorkerRunningEvent;
use Symfony\Component\Messenger\Exception\HandlerFailedException;

final class RestartWorkerListener implements EventSubscriberInterface
{
    private const array EXCEPTIONS_TO_RESTART_WORKER = [
        // Redis cannot recover from a connection error.
        \RedisException::class,
    ];

    private bool $stop = false;

    public function __construct(
        private readonly LoggerInterface $logger = new NullLogger(),
    ) {
    }

    public function onMessageFailed(WorkerMessageFailedEvent $event): void
    {
        $e = $event->getThrowable();

        if ($this->stopIfNeeded($e)) {
            return;
        }

        if ($e instanceof HandlerFailedException) {
            foreach ($e->getWrappedExceptions() as $e) {
                if ($this->stopIfNeeded($e)) {
                    return;
                }
            }
        }
    }

    public function onWorkerRunning(WorkerRunningEvent $event): void
    {
        if ($this->stop) {
            $event->getWorker()->stop();
        }
    }

    public static function getSubscribedEvents(): array
    {
        return [
            WorkerMessageFailedEvent::class => 'onMessageFailed',
            WorkerRunningEvent::class => 'onWorkerRunning',
        ];
    }

    private function stopIfNeeded(\Throwable $e): bool
    {
        if ($this->shouldRestartWorker($e)) {
            $this->stop = true;

            $this->logger->error('Worker will stop due to an error.', [
                'exception' => $e,
            ]);

            return true;
        }

        return false;
    }

    private function shouldRestartWorker(\Throwable $e): bool
    {
        foreach (self::EXCEPTIONS_TO_RESTART_WORKER as $exception) {
            if ($e instanceof $exception) {
                return true;
            }
        }

        return false;
    }
}

Et voilà 🤓 Avec ce listener et quelques modifications de la constante EXCEPTIONS_TO_RESTART_WORKER vous pourrez laisser votre worker re-démarrer en toute sérénité.

Protip : pour tester une instabilité entre PHP et un composant externe et, si vous utilisez docker, vous pouvez mettre en pause votre container :

docker pause app-redis-1
docker unpause app-redis-1