vendor/symfony/event-dispatcher/Debug/TraceableEventDispatcher.php line 168

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\EventDispatcher\Debug;
  11. use Psr\EventDispatcher\StoppableEventInterface;
  12. use Psr\Log\LoggerInterface;
  13. use Symfony\Component\BrowserKit\Request;
  14. use Symfony\Component\EventDispatcher\Event;
  15. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  16. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  17. use Symfony\Component\EventDispatcher\LegacyEventDispatcherProxy;
  18. use Symfony\Component\EventDispatcher\LegacyEventProxy;
  19. use Symfony\Component\HttpFoundation\RequestStack;
  20. use Symfony\Component\Stopwatch\Stopwatch;
  21. use Symfony\Contracts\EventDispatcher\Event as ContractsEvent;
  22. /**
  23.  * Collects some data about event listeners.
  24.  *
  25.  * This event dispatcher delegates the dispatching to another one.
  26.  *
  27.  * @author Fabien Potencier <fabien@symfony.com>
  28.  */
  29. class TraceableEventDispatcher implements TraceableEventDispatcherInterface
  30. {
  31.     protected $logger;
  32.     protected $stopwatch;
  33.     private $callStack;
  34.     private $dispatcher;
  35.     private $wrappedListeners;
  36.     private $orphanedEvents;
  37.     private $requestStack;
  38.     private $currentRequestHash '';
  39.     public function __construct(EventDispatcherInterface $dispatcherStopwatch $stopwatchLoggerInterface $logger nullRequestStack $requestStack null)
  40.     {
  41.         $this->dispatcher LegacyEventDispatcherProxy::decorate($dispatcher);
  42.         $this->stopwatch $stopwatch;
  43.         $this->logger $logger;
  44.         $this->wrappedListeners = [];
  45.         $this->orphanedEvents = [];
  46.         $this->requestStack $requestStack;
  47.     }
  48.     /**
  49.      * {@inheritdoc}
  50.      */
  51.     public function addListener($eventName$listener$priority 0)
  52.     {
  53.         $this->dispatcher->addListener($eventName$listener$priority);
  54.     }
  55.     /**
  56.      * {@inheritdoc}
  57.      */
  58.     public function addSubscriber(EventSubscriberInterface $subscriber)
  59.     {
  60.         $this->dispatcher->addSubscriber($subscriber);
  61.     }
  62.     /**
  63.      * {@inheritdoc}
  64.      */
  65.     public function removeListener($eventName$listener)
  66.     {
  67.         if (isset($this->wrappedListeners[$eventName])) {
  68.             foreach ($this->wrappedListeners[$eventName] as $index => $wrappedListener) {
  69.                 if ($wrappedListener->getWrappedListener() === $listener) {
  70.                     $listener $wrappedListener;
  71.                     unset($this->wrappedListeners[$eventName][$index]);
  72.                     break;
  73.                 }
  74.             }
  75.         }
  76.         return $this->dispatcher->removeListener($eventName$listener);
  77.     }
  78.     /**
  79.      * {@inheritdoc}
  80.      */
  81.     public function removeSubscriber(EventSubscriberInterface $subscriber)
  82.     {
  83.         return $this->dispatcher->removeSubscriber($subscriber);
  84.     }
  85.     /**
  86.      * {@inheritdoc}
  87.      */
  88.     public function getListeners($eventName null)
  89.     {
  90.         return $this->dispatcher->getListeners($eventName);
  91.     }
  92.     /**
  93.      * {@inheritdoc}
  94.      */
  95.     public function getListenerPriority($eventName$listener)
  96.     {
  97.         // we might have wrapped listeners for the event (if called while dispatching)
  98.         // in that case get the priority by wrapper
  99.         if (isset($this->wrappedListeners[$eventName])) {
  100.             foreach ($this->wrappedListeners[$eventName] as $index => $wrappedListener) {
  101.                 if ($wrappedListener->getWrappedListener() === $listener) {
  102.                     return $this->dispatcher->getListenerPriority($eventName$wrappedListener);
  103.                 }
  104.             }
  105.         }
  106.         return $this->dispatcher->getListenerPriority($eventName$listener);
  107.     }
  108.     /**
  109.      * {@inheritdoc}
  110.      */
  111.     public function hasListeners($eventName null)
  112.     {
  113.         return $this->dispatcher->hasListeners($eventName);
  114.     }
  115.     /**
  116.      * {@inheritdoc}
  117.      *
  118.      * @param string|null $eventName
  119.      */
  120.     public function dispatch($event/*, string $eventName = null*/)
  121.     {
  122.         if (null === $this->callStack) {
  123.             $this->callStack = new \SplObjectStorage();
  124.         }
  125.         $currentRequestHash $this->currentRequestHash $this->requestStack && ($request $this->requestStack->getCurrentRequest()) ? spl_object_hash($request) : '';
  126.         $eventName < \func_num_args() ? \func_get_arg(1) : null;
  127.         if (\is_object($event)) {
  128.             $eventName $eventName ?? \get_class($event);
  129.         } else {
  130.             @trigger_error(sprintf('Calling the "%s::dispatch()" method with the event name as first argument is deprecated since Symfony 4.3, pass it second and provide the event object first instead.'EventDispatcherInterface::class), E_USER_DEPRECATED);
  131.             $swap $event;
  132.             $event $eventName ?? new Event();
  133.             $eventName $swap;
  134.             if (!$event instanceof Event) {
  135.                 throw new \TypeError(sprintf('Argument 1 passed to "%s::dispatch()" must be an instance of %s, %s given.'EventDispatcherInterface::class, Event::class, \is_object($event) ? \get_class($event) : \gettype($event)));
  136.             }
  137.         }
  138.         if (null !== $this->logger && ($event instanceof Event || $event instanceof ContractsEvent || $event instanceof StoppableEventInterface) && $event->isPropagationStopped()) {
  139.             $this->logger->debug(sprintf('The "%s" event is already stopped. No listeners have been called.'$eventName));
  140.         }
  141.         $this->preProcess($eventName);
  142.         try {
  143.             $this->beforeDispatch($eventName$event);
  144.             try {
  145.                 $e $this->stopwatch->start($eventName'section');
  146.                 try {
  147.                     $this->dispatcher->dispatch($event$eventName);
  148.                 } finally {
  149.                     if ($e->isStarted()) {
  150.                         $e->stop();
  151.                     }
  152.                 }
  153.             } finally {
  154.                 $this->afterDispatch($eventName$event);
  155.             }
  156.         } finally {
  157.             $this->currentRequestHash $currentRequestHash;
  158.             $this->postProcess($eventName);
  159.         }
  160.         return $event;
  161.     }
  162.     /**
  163.      * {@inheritdoc}
  164.      *
  165.      * @param Request|null $request The request to get listeners for
  166.      */
  167.     public function getCalledListeners(/* Request $request = null */)
  168.     {
  169.         if (null === $this->callStack) {
  170.             return [];
  171.         }
  172.         $hash <= \func_num_args() && null !== ($request = \func_get_arg(0)) ? spl_object_hash($request) : null;
  173.         $called = [];
  174.         foreach ($this->callStack as $listener) {
  175.             list($eventName$requestHash) = $this->callStack->getInfo();
  176.             if (null === $hash || $hash === $requestHash) {
  177.                 $called[] = $listener->getInfo($eventName);
  178.             }
  179.         }
  180.         return $called;
  181.     }
  182.     /**
  183.      * {@inheritdoc}
  184.      *
  185.      * @param Request|null $request The request to get listeners for
  186.      */
  187.     public function getNotCalledListeners(/* Request $request = null */)
  188.     {
  189.         try {
  190.             $allListeners $this->getListeners();
  191.         } catch (\Exception $e) {
  192.             if (null !== $this->logger) {
  193.                 $this->logger->info('An exception was thrown while getting the uncalled listeners.', ['exception' => $e]);
  194.             }
  195.             // unable to retrieve the uncalled listeners
  196.             return [];
  197.         }
  198.         $hash <= \func_num_args() && null !== ($request = \func_get_arg(0)) ? spl_object_hash($request) : null;
  199.         $notCalled = [];
  200.         foreach ($allListeners as $eventName => $listeners) {
  201.             foreach ($listeners as $listener) {
  202.                 $called false;
  203.                 if (null !== $this->callStack) {
  204.                     foreach ($this->callStack as $calledListener) {
  205.                         list(, $requestHash) = $this->callStack->getInfo();
  206.                         if ((null === $hash || $hash === $requestHash) && $calledListener->getWrappedListener() === $listener) {
  207.                             $called true;
  208.                             break;
  209.                         }
  210.                     }
  211.                 }
  212.                 if (!$called) {
  213.                     if (!$listener instanceof WrappedListener) {
  214.                         $listener = new WrappedListener($listenernull$this->stopwatch$this);
  215.                     }
  216.                     $notCalled[] = $listener->getInfo($eventName);
  217.                 }
  218.             }
  219.         }
  220.         uasort($notCalled, [$this'sortNotCalledListeners']);
  221.         return $notCalled;
  222.     }
  223.     /**
  224.      * @param Request|null $request The request to get orphaned events for
  225.      */
  226.     public function getOrphanedEvents(/* Request $request = null */): array
  227.     {
  228.         if (<= \func_num_args() && null !== $request = \func_get_arg(0)) {
  229.             return $this->orphanedEvents[spl_object_hash($request)] ?? [];
  230.         }
  231.         if (!$this->orphanedEvents) {
  232.             return [];
  233.         }
  234.         return array_merge(...array_values($this->orphanedEvents));
  235.     }
  236.     public function reset()
  237.     {
  238.         $this->callStack null;
  239.         $this->orphanedEvents = [];
  240.         $this->currentRequestHash '';
  241.     }
  242.     /**
  243.      * Proxies all method calls to the original event dispatcher.
  244.      *
  245.      * @param string $method    The method name
  246.      * @param array  $arguments The method arguments
  247.      *
  248.      * @return mixed
  249.      */
  250.     public function __call($method$arguments)
  251.     {
  252.         return $this->dispatcher->{$method}(...$arguments);
  253.     }
  254.     /**
  255.      * Called before dispatching the event.
  256.      *
  257.      * @param object $event
  258.      */
  259.     protected function beforeDispatch(string $eventName$event)
  260.     {
  261.         $this->preDispatch($eventName$event instanceof Event $event : new LegacyEventProxy($event));
  262.     }
  263.     /**
  264.      * Called after dispatching the event.
  265.      *
  266.      * @param object $event
  267.      */
  268.     protected function afterDispatch(string $eventName$event)
  269.     {
  270.         $this->postDispatch($eventName$event instanceof Event $event : new LegacyEventProxy($event));
  271.     }
  272.     /**
  273.      * @deprecated since Symfony 4.3, will be removed in 5.0, use beforeDispatch instead
  274.      */
  275.     protected function preDispatch($eventNameEvent $event)
  276.     {
  277.     }
  278.     /**
  279.      * @deprecated since Symfony 4.3, will be removed in 5.0, use afterDispatch instead
  280.      */
  281.     protected function postDispatch($eventNameEvent $event)
  282.     {
  283.     }
  284.     private function preProcess($eventName)
  285.     {
  286.         if (!$this->dispatcher->hasListeners($eventName)) {
  287.             $this->orphanedEvents[$this->currentRequestHash][] = $eventName;
  288.             return;
  289.         }
  290.         foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  291.             $priority $this->getListenerPriority($eventName$listener);
  292.             $wrappedListener = new WrappedListener($listener instanceof WrappedListener $listener->getWrappedListener() : $listenernull$this->stopwatch$this);
  293.             $this->wrappedListeners[$eventName][] = $wrappedListener;
  294.             $this->dispatcher->removeListener($eventName$listener);
  295.             $this->dispatcher->addListener($eventName$wrappedListener$priority);
  296.             $this->callStack->attach($wrappedListener, [$eventName$this->currentRequestHash]);
  297.         }
  298.     }
  299.     private function postProcess($eventName)
  300.     {
  301.         unset($this->wrappedListeners[$eventName]);
  302.         $skipped false;
  303.         foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  304.             if (!$listener instanceof WrappedListener) { // #12845: a new listener was added during dispatch.
  305.                 continue;
  306.             }
  307.             // Unwrap listener
  308.             $priority $this->getListenerPriority($eventName$listener);
  309.             $this->dispatcher->removeListener($eventName$listener);
  310.             $this->dispatcher->addListener($eventName$listener->getWrappedListener(), $priority);
  311.             if (null !== $this->logger) {
  312.                 $context = ['event' => $eventName'listener' => $listener->getPretty()];
  313.             }
  314.             if ($listener->wasCalled()) {
  315.                 if (null !== $this->logger) {
  316.                     $this->logger->debug('Notified event "{event}" to listener "{listener}".'$context);
  317.                 }
  318.             } else {
  319.                 $this->callStack->detach($listener);
  320.             }
  321.             if (null !== $this->logger && $skipped) {
  322.                 $this->logger->debug('Listener "{listener}" was not called for event "{event}".'$context);
  323.             }
  324.             if ($listener->stoppedPropagation()) {
  325.                 if (null !== $this->logger) {
  326.                     $this->logger->debug('Listener "{listener}" stopped propagation of the event "{event}".'$context);
  327.                 }
  328.                 $skipped true;
  329.             }
  330.         }
  331.     }
  332.     private function sortNotCalledListeners(array $a, array $b)
  333.     {
  334.         if (!== $cmp strcmp($a['event'], $b['event'])) {
  335.             return $cmp;
  336.         }
  337.         if (\is_int($a['priority']) && !\is_int($b['priority'])) {
  338.             return 1;
  339.         }
  340.         if (!\is_int($a['priority']) && \is_int($b['priority'])) {
  341.             return -1;
  342.         }
  343.         if ($a['priority'] === $b['priority']) {
  344.             return 0;
  345.         }
  346.         if ($a['priority'] > $b['priority']) {
  347.             return -1;
  348.         }
  349.         return 1;
  350.     }
  351. }