Présentation de la surveillance Symfony Messenger

Améliorez l'évolutivité des applications Symfony avec Symfony Messenger et Inspector Bundle

En tant que développeur Symfony, l'optimisation des performances et de l'évolutivité des applications est primordiale. Le composant Symfony Messenger offre une solution puissante pour le traitement des tâches asynchrones, mais la surveillance de ces opérations en arrière-plan peut s'avérer difficile. Cet article présente une nouvelle fonctionnalité dans le bundle Inspector qui offre une visibilité complète sur vos tâches en arrière-plan Symfony Messenger, éliminant ainsi le besoin d'une analyse manuelle des journaux ou d'un code de surveillance personnalisé.

Cette nouvelle fonctionnalité permet une surveillance automatique de chaque aspect de vos tâches en arrière-plan. Des temps d'exécution et de la consommation de mémoire aux requêtes de base de données, aux erreurs et aux goulots d'étranglement potentiels, vous obtenez un aperçu instantané grâce à un tableau de bord convivial, le tout sans aucune configuration requise.

Le défi typique des développeurs demeure : déployer une gestion des messages asynchrone et espérer un fonctionnement en arrière-plan fluide. Bien que Symfony Messenger soit robuste, la surveillance des processus en arrière-plan a toujours été un angle mort. Cet article approfondit les détails de mise en œuvre pour mettre en évidence les avantages significatifs pour le développement quotidien.

Qu'est-ce qu'un système de file d'attente ?

Un système de file d'attente est un élément crucial dans les applications Web modernes, permettant de séparer les tâches chronophages du cycle principal demande-réponse. Au lieu de traiter des opérations gourmandes en ressources lors des demandes des utilisateurs (par exemple, envoi d'e-mails, traitement d'images, génération de rapports), ces tâches sont mises en file d'attente pour une gestion asynchrone par les travailleurs en arrière-plan. Cela améliore la réactivité des applications, car les utilisateurs n'attendent pas de longues opérations, et améliore la gestion des ressources en contrôlant le traitement des tâches simultanées. Les systèmes de files d'attente intègrent souvent des mécanismes de nouvelle tentative pour plus de fiabilité en cas d'échec de tâche. À mesure que votre application évolue, l'adoption de cette approche devient essentielle pour servir davantage d'utilisateurs sans augmenter les coûts d'infrastructure.

Composant Symfony Messenger

Le composant Symfony Messenger est un système de file d'attente puissant intégré au framework Symfony. Il facilite la publication et la consommation de messages provenant de différents fournisseurs de files d'attente (AMQP, Redis, Doctrine). Les messages sont de simples classes contenant des données représentant la tâche.

Voici un exemple de message :

namespace App\Messenger;

class SmsNotification
{
    public function __construct(private string $content) {}
    public function getContent(): string { return $this->content; }
}

Un gestionnaire correspondant traite le message lorsqu'il est récupéré de la file d'attente :

namespace App\Messenger;

class SmsNotification
{
    public function __construct(private string $content) {}
    public function getContent(): string { return $this->content; }
}

Notez l'attribut #[AsMessageHandler] et l'indice de type pour SmsNotification dans la méthode __invoke. C'est ainsi que Symfony identifie les gestionnaires de messages spécifiques. La commande messenger:consume exécute un travailleur en arrière-plan pour traiter les messages en file d'attente et exécuter les gestionnaires appropriés en dehors du cycle demande-réponse. Pour envoyer un message de manière asynchrone :

namespace App\Messenger;

use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler]
class SmsNotificationHandler
{
    public function __invoke(SmsNotification $message)
    {
        // ... send SMS message ...
    }
}

Messenger simplifie le traitement asynchrone complexe avec des fonctionnalités telles que la sérialisation automatique des messages, la prise en charge des middlewares et les stratégies de nouvelle tentative.

Middleware de surveillance Symfony Messenger

La surveillance des processus en arrière-plan, qui fonctionnent en dehors du point de vue de l'utilisateur et du développeur, présente des défis uniques. Des questions se posent : combien de temps prennent les gestionnaires ? Des opérations de base de données coûteuses sont-elles effectuées ? Les tâches en arrière-plan échouent-elles silencieusement ?

Inspector résout ces problèmes en fournissant une interface conviviale pour surveiller les processus en arrière-plan avec la même efficacité que l'application principale.

Architecture middleware Symfony Messenger

Le package Inspector enregistre un middleware de messagerie pour suivre le début et la fin du traitement des messages. Il exploite les fonctionnalités existantes pour collecter les requêtes de base de données et d'autres actions lors de la gestion des messages. Un middleware dans Symfony Messenger agit comme un wrapper autour de la gestion des messages, permettant des actions avant et après la gestion. Cela utilise le modèle de conception de la chaîne de responsabilité.

Implémentation du middleware Inspector

Le middleware est implémenté pour exécuter du code avant et après la gestion des messages :

namespace App\Controller;

use App\Messenger\SmsNotification;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Routing\Attribute\Route;

class HomeController extends AbstractController
{
    #[Route('/', name: 'home')]
    public function home(MessageBusInterface $bus)
    {
        $bus->dispatch(new SmsNotification("New Message!"));
        return new Response('SMS notification dispatched.');
    }
}

Ce composant plug-and-play simplifie la surveillance des processus en arrière-plan lors de la mise à jour des dépendances des applications.

Mise à niveau vers la version 1.5

La version 1.5 est une version mineure, facilement installée via composer update. Messenger Monitoring s'intègre automatiquement sans modification de code.

Ignorer les messages

Pour réduire le bruit, Inspector permet d'ignorer des messages ou des modèles spécifiques en utilisant la propriété ignore_messages dans inspector.yaml :

namespace App\Messenger\Middlewares;

use Symfony\Component\Messenger\Middleware\MiddlewareInterface;
use Symfony\Component\Messenger\Middleware\StackInterface;

class MessengerMonitoringMiddleware implements MiddlewareInterface
{
    public function handle(Envelope $envelope, StackInterface $stack): Envelope
    {
        // Before handling
        $this->beforeHandle($envelope);

        // Handle the message
        $envelope = $stack->next()->handle($envelope, $stack);

        // After handling
        $this->afterHandle($envelope);
    }
}

Surveillez votre application Symfony avec Inspector

Inspector offre une surveillance HTTP gratuite, des informations sur les requêtes de base de données et le transfert d'alertes. Installez simplement le package Symfony pour commencer. Apprenez-en plus sur https://www.php.cn/link/3a78f1864ab77dbd239fbe33cae90bbb

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!