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

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\EventDispatcher\Debug;
  14. use Psr\Log\LoggerInterface;
  15. use Symfony\Component\EventDispatcher\Event;
  16. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  17. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  18. use Symfony\Component\Stopwatch\Stopwatch;
  20. /**
  21.  * Collects some data about event listeners.
  22.  *
  23.  * This event dispatcher delegates the dispatching to another one.
  24.  *
  25.  * @author Fabien Potencier <fabien@symfony.com>
  26.  */
  27. class TraceableEventDispatcher implements TraceableEventDispatcherInterface {
  29.     protected $logger;
  30.     protected $stopwatch;
  31.     private $callStack;
  32.     private $dispatcher;
  33.     private $wrappedListeners;
  34.     private $orphanedEvents;
  36.     public function __construct(EventDispatcherInterface $dispatcher, Stopwatch $stopwatch, LoggerInterface $logger = null) {
  37.         $this->dispatcher = $dispatcher;
  38.         $this->stopwatch = $stopwatch;
  39.         $this->logger = $logger;
  40.         $this->wrappedListeners = [];
  41.         $this->orphanedEvents = [];
  42.     }
  44.     /**
  45.      * {@inheritdoc}
  46.      */
  47.     public function addListener($eventName, $listener, $priority = 0) {
  48.         $this->dispatcher->addListener($eventName, $listener, $priority);
  49.     }
  51.     /**
  52.      * {@inheritdoc}
  53.      */
  54.     public function addSubscriber(EventSubscriberInterface $subscriber) {
  55.         $this->dispatcher->addSubscriber($subscriber);
  56.     }
  58.     /**
  59.      * {@inheritdoc}
  60.      */
  61.     public function removeListener($eventName, $listener) {
  62.         if (isset($this->wrappedListeners[$eventName])) {
  63.             foreach ($this->wrappedListeners[$eventName] as $index => $wrappedListener) {
  64.                 if ($wrappedListener->getWrappedListener() === $listener) {
  65.                     $listener = $wrappedListener;
  66.                     unset($this->wrappedListeners[$eventName][$index]);
  67.                     break;
  68.                 }
  69.             }
  70.         }
  72.         return $this->dispatcher->removeListener($eventName, $listener);
  73.     }
  75.     /**
  76.      * {@inheritdoc}
  77.      */
  78.     public function removeSubscriber(EventSubscriberInterface $subscriber) {
  79.         return $this->dispatcher->removeSubscriber($subscriber);
  80.     }
  82.     /**
  83.      * {@inheritdoc}
  84.      */
  85.     public function getListeners($eventName = null) {
  86.         return $this->dispatcher->getListeners($eventName);
  87.     }
  89.     /**
  90.      * {@inheritdoc}
  91.      */
  92.     public function getListenerPriority($eventName, $listener) {
  93.         // we might have wrapped listeners for the event (if called while dispatching)
  94.         // in that case get the priority by wrapper
  95.         if (isset($this->wrappedListeners[$eventName])) {
  96.             foreach ($this->wrappedListeners[$eventName] as $index => $wrappedListener) {
  97.                 if ($wrappedListener->getWrappedListener() === $listener) {
  98.                     return $this->dispatcher->getListenerPriority($eventName, $wrappedListener);
  99.                 }
  100.             }
  101.         }
  103.         return $this->dispatcher->getListenerPriority($eventName, $listener);
  104.     }
  106.     /**
  107.      * {@inheritdoc}
  108.      */
  109.     public function hasListeners($eventName = null) {
  110.         return $this->dispatcher->hasListeners($eventName);
  111.     }
  113.     /**
  114.      * {@inheritdoc}
  115.      */
  116.     public function dispatch($eventName, Event $event = null) {
  117.         if (null === $this->callStack) {
  118.             $this->callStack = new \SplObjectStorage();
  119.         }
  121.         if (null === $event) {
  122.             $event = new Event();
  123.         }
  125.         if (null !== $this->logger && $event->isPropagationStopped()) {
  126.             $this->logger->debug(sprintf('The "%s" event is already stopped. No listeners have been called.', $eventName));
  127.         }
  129.         $this->preProcess($eventName);
  130.         try {
  131.             $this->preDispatch($eventName, $event);
  132.             try {
  133.                 $e = $this->stopwatch->start($eventName, 'section');
  134.                 try {
  135.                     $this->dispatcher->dispatch($eventName, $event);
  136.                 } finally {
  137.                     if ($e->isStarted()) {
  138.                         $e->stop();
  139.                     }
  140.                 }
  141.             } finally {
  142.                 $this->postDispatch($eventName, $event);
  143.             }
  144.         } finally {
  145.             $this->postProcess($eventName);
  146.         }
  148.         return $event;
  149.     }
  151.     /**
  152.      * {@inheritdoc}
  153.      */
  154.     public function getCalledListeners() {
  155.         if (null === $this->callStack) {
  156.             return [];
  157.         }
  159.         $called = [];
  160.         foreach ($this->callStack as $listener) {
  161.             list($eventName) = $this->callStack->getInfo();
  163.             $called[] = $listener->getInfo($eventName);
  164.         }
  166.         return $called;
  167.     }
  169.     /**
  170.      * {@inheritdoc}
  171.      */
  172.     public function getNotCalledListeners() {
  173.         try {
  174.             $allListeners = $this->getListeners();
  175.         } catch (\Exception $e) {
  176.             if (null !== $this->logger) {
  177.                 $this->logger->info('An exception was thrown while getting the uncalled listeners.', ['exception' => $e]);
  178.             }
  180.             // unable to retrieve the uncalled listeners
  181.             return [];
  182.         }
  184.         $calledListeners = [];
  186.         if (null !== $this->callStack) {
  187.             foreach ($this->callStack as $calledListener) {
  188.                 $calledListeners[] = $calledListener->getWrappedListener();
  189.             }
  190.         }
  192.         $notCalled = [];
  193.         foreach ($allListeners as $eventName => $listeners) {
  194.             foreach ($listeners as $listener) {
  195.                 if (!\in_array($listener, $calledListeners, true)) {
  196.                     if (!$listener instanceof WrappedListener) {
  197.                         $listener = new WrappedListener($listener, null, $this->stopwatch, $this);
  198.                     }
  199.                     $notCalled[] = $listener->getInfo($eventName);
  200.                 }
  201.             }
  202.         }
  204.         uasort($notCalled, [$this, 'sortNotCalledListeners']);
  206.         return $notCalled;
  207.     }
  209.     public function getOrphanedEvents(): array {
  210.         return $this->orphanedEvents;
  211.     }
  213.     public function reset() {
  214.         $this->callStack = null;
  215.         $this->orphanedEvents = [];
  216.     }
  218.     /**
  219.      * Proxies all method calls to the original event dispatcher.
  220.      *
  221.      * @param string $method    The method name
  222.      * @param array  $arguments The method arguments
  223.      *
  224.      * @return mixed
  225.      */
  226.     public function __call($method, $arguments) {
  227.         return $this->dispatcher->{$method}(...$arguments);
  228.     }
  230.     /**
  231.      * Called before dispatching the event.
  232.      *
  233.      * @param string $eventName The event name
  234.      * @param Event  $event     The event
  235.      */
  236.     protected function preDispatch($eventName, Event $event) {
  237.         
  238.     }
  240.     /**
  241.      * Called after dispatching the event.
  242.      *
  243.      * @param string $eventName The event name
  244.      * @param Event  $event     The event
  245.      */
  246.     protected function postDispatch($eventName, Event $event) {
  247.         
  248.     }
  250.     private function preProcess($eventName) {
  251.         if (!$this->dispatcher->hasListeners($eventName)) {
  252.             $this->orphanedEvents[] = $eventName;
  254.             return;
  255.         }
  257.         foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  258.             $priority = $this->getListenerPriority($eventName, $listener);
  259.             $wrappedListener = new WrappedListener($listener instanceof WrappedListener ? $listener->getWrappedListener() : $listener, null, $this->stopwatch, $this);
  260.             $this->wrappedListeners[$eventName][] = $wrappedListener;
  261.             $this->dispatcher->removeListener($eventName, $listener);
  262.             $this->dispatcher->addListener($eventName, $wrappedListener, $priority);
  263.             $this->callStack->attach($wrappedListener, [$eventName]);
  264.         }
  265.     }
  267.     private function postProcess($eventName) {
  268.         unset($this->wrappedListeners[$eventName]);
  269.         $skipped = false;
  270.         foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  271.             if (!$listener instanceof WrappedListener) { // #12845: a new listener was added during dispatch.
  272.                 continue;
  273.             }
  274.             // Unwrap listener
  275.             $priority = $this->getListenerPriority($eventName, $listener);
  276.             $this->dispatcher->removeListener($eventName, $listener);
  277.             $this->dispatcher->addListener($eventName, $listener->getWrappedListener(), $priority);
  279.             if (null !== $this->logger) {
  280.                 $context = ['event' => $eventName, 'listener' => $listener->getPretty()];
  281.             }
  283.             if ($listener->wasCalled()) {
  284.                 if (null !== $this->logger) {
  285.                     $this->logger->debug('Notified event "{event}" to listener "{listener}".', $context);
  286.                 }
  287.             } else {
  288.                 $this->callStack->detach($listener);
  289.             }
  291.             if (null !== $this->logger && $skipped) {
  292.                 $this->logger->debug('Listener "{listener}" was not called for event "{event}".', $context);
  293.             }
  295.             if ($listener->stoppedPropagation()) {
  296.                 if (null !== $this->logger) {
  297.                     $this->logger->debug('Listener "{listener}" stopped propagation of the event "{event}".', $context);
  298.                 }
  300.                 $skipped = true;
  301.             }
  302.         }
  303.     }
  305.     private function sortNotCalledListeners(array $a, array $b) {
  306.         if (0 !== $cmp = strcmp($a['event'], $b['event'])) {
  307.             return $cmp;
  308.         }
  310.         if (\is_int($a['priority']) && !\is_int($b['priority'])) {
  311.             return 1;
  312.         }
  314.         if (!\is_int($a['priority']) && \is_int($b['priority'])) {
  315.             return -1;
  316.         }
  318.         if ($a['priority'] === $b['priority']) {
  319.             return 0;
  320.         }
  322.         if ($a['priority'] > $b['priority']) {
  323.             return -1;
  324.         }
  326.         return 1;
  327.     }
  329. }