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

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Sentry\SentryBundle\EventListener;
  7. use Sentry\Event;
  8. use Sentry\EventHint;
  9. use Sentry\ExceptionMechanism;
  10. use Sentry\State\HubInterface;
  11. use Sentry\State\Scope;
  12. use Symfony\Component\Messenger\Event\WorkerMessageFailedEvent;
  13. use Symfony\Component\Messenger\Event\WorkerMessageHandledEvent;
  14. use Symfony\Component\Messenger\Exception\DelayedMessageHandlingException;
  15. use Symfony\Component\Messenger\Exception\HandlerFailedException;
  16. use Symfony\Component\Messenger\Stamp\BusNameStamp;
  18. final class MessengerListener
  19. {
  20.     /**
  21.      * @var HubInterface The current hub
  22.      */
  23.     private $hub;
  25.     /**
  26.      * @var bool Whether to capture errors thrown while processing a message that
  27.      *           will be retried
  28.      */
  29.     private $captureSoftFails;
  31.     /**
  32.      * @param HubInterface $hub              The current hub
  33.      * @param bool         $captureSoftFails Whether to capture errors thrown
  34.      *                                       while processing a message that
  35.      *                                       will be retried
  36.      */
  37.     public function __construct(HubInterface $hub, bool $captureSoftFails = true)
  38.     {
  39.         $this->hub = $hub;
  40.         $this->captureSoftFails = $captureSoftFails;
  41.     }
  43.     /**
  44.      * This method is called for each message that failed to be handled.
  45.      *
  46.      * @param WorkerMessageFailedEvent $event The event
  47.      */
  48.     public function handleWorkerMessageFailedEvent(WorkerMessageFailedEvent $event): void
  49.     {
  50.         if (!$this->captureSoftFails && $event->willRetry()) {
  51.             return;
  52.         }
  54.         $this->hub->withScope(function (Scope $scope) use ($event): void {
  55.             $envelope = $event->getEnvelope();
  56.             $exception = $event->getThrowable();
  58.             $scope->setTag('messenger.receiver_name', $event->getReceiverName());
  59.             $scope->setTag('messenger.message_class', \get_class($envelope->getMessage()));
  61.             /** @var BusNameStamp|null $messageBusStamp */
  62.             $messageBusStamp = $envelope->last(BusNameStamp::class);
  64.             if (null !== $messageBusStamp) {
  65.                 $scope->setTag('messenger.message_bus', $messageBusStamp->getBusName());
  66.             }
  68.             $this->captureException($exception, $event->willRetry());
  69.         });
  71.         $this->flushClient();
  72.     }
  74.     /**
  75.      * This method is called for each handled message.
  76.      *
  77.      * @param WorkerMessageHandledEvent $event The event
  78.      */
  79.     public function handleWorkerMessageHandledEvent(WorkerMessageHandledEvent $event): void
  80.     {
  81.         // Flush normally happens at shutdown... which only happens in the worker if it is run with a lifecycle limit
  82.         // such as --time=X or --limit=Y. Flush immediately in a background worker.
  83.         $this->flushClient();
  84.     }
  86.     /**
  87.      * Creates Sentry events from the given exception.
  88.      *
  89.      * Unpacks multiple exceptions wrapped in a HandlerFailedException and notifies
  90.      * Sentry of each individual exception.
  91.      *
  92.      * If the message will be retried the exceptions will be marked as handled
  93.      * in Sentry.
  94.      */
  95.     private function captureException(\Throwable $exception, bool $willRetry): void
  96.     {
  97.         if ($exception instanceof HandlerFailedException) {
  98.             $exception = $exception->getNestedExceptions();
  99.         } elseif ($exception instanceof DelayedMessageHandlingException) {
  100.             $exception = $exception->getExceptions();
  101.         }
  103.         if (\is_array($exception)) {
  104.             foreach ($exception as $nestedException) {
  105.                 $this->captureException($nestedException, $willRetry);
  106.             }
  108.             return;
  109.         }
  111.         $hint = EventHint::fromArray([
  112.             'exception' => $exception,
  113.             'mechanism' => new ExceptionMechanism(ExceptionMechanism::TYPE_GENERIC, $willRetry),
  114.         ]);
  116.         $this->hub->captureEvent(Event::createEvent(), $hint);
  117.     }
  119.     private function flushClient(): void
  120.     {
  121.         $client = $this->hub->getClient();
  123.         if (null !== $client) {
  124.             $client->flush();
  125.         }
  126.     }
  127. }