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

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