vendor/sentry/sentry-symfony/src/EventListener/MessengerListener.php line 45

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Sentry\SentryBundle\EventListener;
  7. use Sentry\Event;
  8. use Sentry\State\HubInterface;
  9. use Sentry\State\Scope;
  10. use Symfony\Component\Messenger\Event\WorkerMessageFailedEvent;
  11. use Symfony\Component\Messenger\Event\WorkerMessageHandledEvent;
  12. use Symfony\Component\Messenger\Exception\HandlerFailedException;
  13. use Symfony\Component\Messenger\Stamp\BusNameStamp;
  15. final class MessengerListener
  16. {
  17.     /**
  18.      * @var HubInterface The current hub
  19.      */
  20.     private $hub;
  22.     /**
  23.      * @var bool Whether to capture errors thrown while processing a message that
  24.      *           will be retried
  25.      */
  26.     private $captureSoftFails;
  28.     /**
  29.      * @param HubInterface $hub              The current hub
  30.      * @param bool         $captureSoftFails Whether to capture errors thrown
  31.      *                                       while processing a message that
  32.      *                                       will be retried
  33.      */
  34.     public function __construct(HubInterface $hub, bool $captureSoftFails = true)
  35.     {
  36.         $this->hub = $hub;
  37.         $this->captureSoftFails = $captureSoftFails;
  38.     }
  40.     /**
  41.      * This method is called for each message that failed to be handled.
  42.      *
  43.      * @param WorkerMessageFailedEvent $event The event
  44.      */
  45.     public function handleWorkerMessageFailedEvent(WorkerMessageFailedEvent $event): void
  46.     {
  47.         if (!$this->captureSoftFails && $event->willRetry()) {
  48.             return;
  49.         }
  51.         $this->hub->withScope(function (Scope $scope) use ($event): void {
  52.             $envelope = $event->getEnvelope();
  53.             $exception = $event->getThrowable();
  55.             $scope->setTag('messenger.receiver_name', $event->getReceiverName());
  56.             $scope->setTag('messenger.message_class', \get_class($envelope->getMessage()));
  58.             /** @var BusNameStamp|null $messageBusStamp */
  59.             $messageBusStamp = $envelope->last(BusNameStamp::class);
  61.             if (null !== $messageBusStamp) {
  62.                 $scope->setTag('messenger.message_bus', $messageBusStamp->getBusName());
  63.             }
  65.             if ($exception instanceof HandlerFailedException) {
  66.                 foreach ($exception->getNestedExceptions() as $nestedException) {
  67.                     $this->hub->captureException($nestedException);
  68.                 }
  69.             } else {
  70.                 $this->hub->captureException($exception);
  71.             }
  72.         });
  74.         $this->flushClient();
  75.     }
  77.     /**
  78.      * This method is called for each handled message.
  79.      *
  80.      * @param WorkerMessageHandledEvent $event The event
  81.      */
  82.     public function handleWorkerMessageHandledEvent(WorkerMessageHandledEvent $event): void
  83.     {
  84.         // Flush normally happens at shutdown... which only happens in the worker if it is run with a lifecycle limit
  85.         // such as --time=X or --limit=Y. Flush immediately in a background worker.
  86.         $this->flushClient();
  87.     }
  89.     private function flushClient(): void
  90.     {
  91.         $client = $this->hub->getClient();
  93.         if (null !== $client) {
  94.             $client->flush();
  95.         }
  96.     }
  97. }