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

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\HandlerFailedException;
  15. use Symfony\Component\Messenger\Stamp\BusNameStamp;
  17. final class MessengerListener
  18. {
  19.     /**
  20.      * @var HubInterface The current hub
  21.      */
  22.     private $hub;
  24.     /**
  25.      * @var bool Whether to capture errors thrown while processing a message that
  26.      *           will be retried
  27.      */
  28.     private $captureSoftFails;
  30.     /**
  31.      * @param HubInterface $hub              The current hub
  32.      * @param bool         $captureSoftFails Whether to capture errors thrown
  33.      *                                       while processing a message that
  34.      *                                       will be retried
  35.      */
  36.     public function __construct(HubInterface $hub, bool $captureSoftFails = true)
  37.     {
  38.         $this->hub = $hub;
  39.         $this->captureSoftFails = $captureSoftFails;
  40.     }
  42.     /**
  43.      * This method is called for each message that failed to be handled.
  44.      *
  45.      * @param WorkerMessageFailedEvent $event The event
  46.      */
  47.     public function handleWorkerMessageFailedEvent(WorkerMessageFailedEvent $event): void
  48.     {
  49.         if (!$this->captureSoftFails && $event->willRetry()) {
  50.             return;
  51.         }
  53.         $this->hub->withScope(function (Scope $scope) use ($event): void {
  54.             $envelope = $event->getEnvelope();
  55.             $exception = $event->getThrowable();
  57.             $scope->setTag('messenger.receiver_name', $event->getReceiverName());
  58.             $scope->setTag('messenger.message_class', \get_class($envelope->getMessage()));
  60.             /** @var BusNameStamp|null $messageBusStamp */
  61.             $messageBusStamp = $envelope->last(BusNameStamp::class);
  63.             if (null !== $messageBusStamp) {
  64.                 $scope->setTag('messenger.message_bus', $messageBusStamp->getBusName());
  65.             }
  67.             $this->captureException($exception, $event->willRetry());
  68.         });
  70.         $this->flushClient();
  71.     }
  73.     /**
  74.      * This method is called for each handled message.
  75.      *
  76.      * @param WorkerMessageHandledEvent $event The event
  77.      */
  78.     public function handleWorkerMessageHandledEvent(WorkerMessageHandledEvent $event): void
  79.     {
  80.         // Flush normally happens at shutdown... which only happens in the worker if it is run with a lifecycle limit
  81.         // such as --time=X or --limit=Y. Flush immediately in a background worker.
  82.         $this->flushClient();
  83.     }
  85.     /**
  86.      * Creates Sentry events from the given exception.
  87.      *
  88.      * Unpacks multiple exceptions wrapped in a HandlerFailedException and notifies
  89.      * Sentry of each individual exception.
  90.      *
  91.      * If the message will be retried the exceptions will be marked as handled
  92.      * in Sentry.
  93.      */
  94.     private function captureException(\Throwable $exception, bool $willRetry): void
  95.     {
  96.         if ($exception instanceof HandlerFailedException) {
  97.             foreach ($exception->getNestedExceptions() as $nestedException) {
  98.                 $this->captureException($nestedException, $willRetry);
  99.             }
  101.             return;
  102.         }
  104.         $hint = EventHint::fromArray([
  105.             'exception' => $exception,
  106.             'mechanism' => new ExceptionMechanism(ExceptionMechanism::TYPE_GENERIC, $willRetry),
  107.         ]);
  109.         $this->hub->captureEvent(Event::createEvent(), $hint);
  110.     }
  112.     private function flushClient(): void
  113.     {
  114.         $client = $this->hub->getClient();
  116.         if (null !== $client) {
  117.             $client->flush();
  118.         }
  119.     }
  120. }