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

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\EventDispatcher\StoppableEventInterface;
  15. use Psr\Log\LoggerInterface;
  16. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  17. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  18. use Symfony\Component\HttpFoundation\Request;
  19. use Symfony\Component\HttpFoundation\RequestStack;
  20. use Symfony\Component\Stopwatch\Stopwatch;
  21. use Symfony\Contracts\Service\ResetInterface;
  23. /**
  24. * Collects some data about event listeners.
  25. *
  26. * This event dispatcher delegates the dispatching to another one.
  27. *
  28. * @author Fabien Potencier <fabien@symfony.com>
  29. */
  30. class TraceableEventDispatcher implements EventDispatcherInterface, ResetInterface
  31. {
  32. protected $logger;
  33. protected $stopwatch;
  35. /**
  36. * @var \SplObjectStorage<WrappedListener, array{string, string}>
  37. */
  38. private $callStack;
  39. private $dispatcher;
  40. private $wrappedListeners;
  41. private $orphanedEvents;
  42. private $requestStack;
  43. private $currentRequestHash = '';
  45. public function __construct(EventDispatcherInterface $dispatcher, Stopwatch $stopwatch, ?LoggerInterface $logger = null, ?RequestStack $requestStack = null)
  46. {
  47. $this->dispatcher = $dispatcher;
  48. $this->stopwatch = $stopwatch;
  49. $this->logger = $logger;
  50. $this->wrappedListeners = [];
  51. $this->orphanedEvents = [];
  52. $this->requestStack = $requestStack;
  53. }
  55. /**
  56. * {@inheritdoc}
  57. */
  58. public function addListener(string $eventName, $listener, int $priority = 0)
  59. {
  60. $this->dispatcher->addListener($eventName, $listener, $priority);
  61. }
  63. /**
  64. * {@inheritdoc}
  65. */
  66. public function addSubscriber(EventSubscriberInterface $subscriber)
  67. {
  68. $this->dispatcher->addSubscriber($subscriber);
  69. }
  71. /**
  72. * {@inheritdoc}
  73. */
  74. public function removeListener(string $eventName, $listener)
  75. {
  76. if (isset($this->wrappedListeners[$eventName])) {
  77. foreach ($this->wrappedListeners[$eventName] as $index => $wrappedListener) {
  78. if ($wrappedListener->getWrappedListener() === $listener || ($listener instanceof \Closure && $wrappedListener->getWrappedListener() == $listener)) {
  79. $listener = $wrappedListener;
  80. unset($this->wrappedListeners[$eventName][$index]);
  81. break;
  82. }
  83. }
  84. }
  86. return $this->dispatcher->removeListener($eventName, $listener);
  87. }
  89. /**
  90. * {@inheritdoc}
  91. */
  92. public function removeSubscriber(EventSubscriberInterface $subscriber)
  93. {
  94. return $this->dispatcher->removeSubscriber($subscriber);
  95. }
  97. /**
  98. * {@inheritdoc}
  99. */
  100. public function getListeners(?string $eventName = null)
  101. {
  102. return $this->dispatcher->getListeners($eventName);
  103. }
  105. /**
  106. * {@inheritdoc}
  107. */
  108. public function getListenerPriority(string $eventName, $listener)
  109. {
  110. // we might have wrapped listeners for the event (if called while dispatching)
  111. // in that case get the priority by wrapper
  112. if (isset($this->wrappedListeners[$eventName])) {
  113. foreach ($this->wrappedListeners[$eventName] as $wrappedListener) {
  114. if ($wrappedListener->getWrappedListener() === $listener || ($listener instanceof \Closure && $wrappedListener->getWrappedListener() == $listener)) {
  115. return $this->dispatcher->getListenerPriority($eventName, $wrappedListener);
  116. }
  117. }
  118. }
  120. return $this->dispatcher->getListenerPriority($eventName, $listener);
  121. }
  123. /**
  124. * {@inheritdoc}
  125. */
  126. public function hasListeners(?string $eventName = null)
  127. {
  128. return $this->dispatcher->hasListeners($eventName);
  129. }
  131. /**
  132. * {@inheritdoc}
  133. */
  134. public function dispatch(object $event, ?string $eventName = null): object
  135. {
  136. $eventName = $eventName ?? \get_class($event);
  138. if (null === $this->callStack) {
  139. $this->callStack = new \SplObjectStorage();
  140. }
  142. $currentRequestHash = $this->currentRequestHash = $this->requestStack && ($request = $this->requestStack->getCurrentRequest()) ? spl_object_hash($request) : '';
  144. if (null !== $this->logger && $event instanceof StoppableEventInterface && $event->isPropagationStopped()) {
  145. $this->logger->debug(sprintf('The "%s" event is already stopped. No listeners have been called.', $eventName));
  146. }
  148. $this->preProcess($eventName);
  149. try {
  150. $this->beforeDispatch($eventName, $event);
  151. try {
  152. $e = $this->stopwatch->start($eventName, 'section');
  153. try {
  154. $this->dispatcher->dispatch($event, $eventName);
  155. } finally {
  156. if ($e->isStarted()) {
  157. $e->stop();
  158. }
  159. }
  160. } finally {
  161. $this->afterDispatch($eventName, $event);
  162. }
  163. } finally {
  164. $this->currentRequestHash = $currentRequestHash;
  165. $this->postProcess($eventName);
  166. }
  168. return $event;
  169. }
  171. /**
  172. * @return array
  173. */
  174. public function getCalledListeners(?Request $request = null)
  175. {
  176. if (null === $this->callStack) {
  177. return [];
  178. }
  180. $hash = $request ? spl_object_hash($request) : null;
  181. $called = [];
  182. foreach ($this->callStack as $listener) {
  183. [$eventName, $requestHash] = $this->callStack->getInfo();
  184. if (null === $hash || $hash === $requestHash) {
  185. $called[] = $listener->getInfo($eventName);
  186. }
  187. }
  189. return $called;
  190. }
  192. /**
  193. * @return array
  194. */
  195. public function getNotCalledListeners(?Request $request = null)
  196. {
  197. try {
  198. $allListeners = $this->getListeners();
  199. } catch (\Exception $e) {
  200. if (null !== $this->logger) {
  201. $this->logger->info('An exception was thrown while getting the uncalled listeners.', ['exception' => $e]);
  202. }
  204. // unable to retrieve the uncalled listeners
  205. return [];
  206. }
  208. $hash = $request ? spl_object_hash($request) : null;
  209. $calledListeners = [];
  211. if (null !== $this->callStack) {
  212. foreach ($this->callStack as $calledListener) {
  213. [, $requestHash] = $this->callStack->getInfo();
  215. if (null === $hash || $hash === $requestHash) {
  216. $calledListeners[] = $calledListener->getWrappedListener();
  217. }
  218. }
  219. }
  221. $notCalled = [];
  222. foreach ($allListeners as $eventName => $listeners) {
  223. foreach ($listeners as $listener) {
  224. if (!\in_array($listener, $calledListeners, true)) {
  225. if (!$listener instanceof WrappedListener) {
  226. $listener = new WrappedListener($listener, null, $this->stopwatch, $this);
  227. }
  228. $notCalled[] = $listener->getInfo($eventName);
  229. }
  230. }
  231. }
  233. uasort($notCalled, [$this, 'sortNotCalledListeners']);
  235. return $notCalled;
  236. }
  238. public function getOrphanedEvents(?Request $request = null): array
  239. {
  240. if ($request) {
  241. return $this->orphanedEvents[spl_object_hash($request)] ?? [];
  242. }
  244. if (!$this->orphanedEvents) {
  245. return [];
  246. }
  248. return array_merge(...array_values($this->orphanedEvents));
  249. }
  251. public function reset()
  252. {
  253. $this->callStack = null;
  254. $this->orphanedEvents = [];
  255. $this->currentRequestHash = '';
  256. }
  258. /**
  259. * Proxies all method calls to the original event dispatcher.
  260. *
  261. * @param string $method The method name
  262. * @param array $arguments The method arguments
  263. *
  264. * @return mixed
  265. */
  266. public function __call(string $method, array $arguments)
  267. {
  268. return $this->dispatcher->{$method}(...$arguments);
  269. }
  271. /**
  272. * Called before dispatching the event.
  273. */
  274. protected function beforeDispatch(string $eventName, object $event)
  275. {
  276. }
  278. /**
  279. * Called after dispatching the event.
  280. */
  281. protected function afterDispatch(string $eventName, object $event)
  282. {
  283. }
  285. private function preProcess(string $eventName): void
  286. {
  287. if (!$this->dispatcher->hasListeners($eventName)) {
  288. $this->orphanedEvents[$this->currentRequestHash][] = $eventName;
  290. return;
  291. }
  293. foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  294. $priority = $this->getListenerPriority($eventName, $listener);
  295. $wrappedListener = new WrappedListener($listener instanceof WrappedListener ? $listener->getWrappedListener() : $listener, null, $this->stopwatch, $this);
  296. $this->wrappedListeners[$eventName][] = $wrappedListener;
  297. $this->dispatcher->removeListener($eventName, $listener);
  298. $this->dispatcher->addListener($eventName, $wrappedListener, $priority);
  299. $this->callStack->attach($wrappedListener, [$eventName, $this->currentRequestHash]);
  300. }
  301. }
  303. private function postProcess(string $eventName): void
  304. {
  305. unset($this->wrappedListeners[$eventName]);
  306. $skipped = false;
  307. foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  308. if (!$listener instanceof WrappedListener) { // #12845: a new listener was added during dispatch.
  309. continue;
  310. }
  311. // Unwrap listener
  312. $priority = $this->getListenerPriority($eventName, $listener);
  313. $this->dispatcher->removeListener($eventName, $listener);
  314. $this->dispatcher->addListener($eventName, $listener->getWrappedListener(), $priority);
  316. if (null !== $this->logger) {
  317. $context = ['event' => $eventName, 'listener' => $listener->getPretty()];
  318. }
  320. if ($listener->wasCalled()) {
  321. if (null !== $this->logger) {
  322. $this->logger->debug('Notified event "{event}" to listener "{listener}".', $context);
  323. }
  324. } else {
  325. $this->callStack->detach($listener);
  326. }
  328. if (null !== $this->logger && $skipped) {
  329. $this->logger->debug('Listener "{listener}" was not called for event "{event}".', $context);
  330. }
  332. if ($listener->stoppedPropagation()) {
  333. if (null !== $this->logger) {
  334. $this->logger->debug('Listener "{listener}" stopped propagation of the event "{event}".', $context);
  335. }
  337. $skipped = true;
  338. }
  339. }
  340. }
  342. private function sortNotCalledListeners(array $a, array $b)
  343. {
  344. if (0 !== $cmp = strcmp($a['event'], $b['event'])) {
  345. return $cmp;
  346. }
  348. if (\is_int($a['priority']) && !\is_int($b['priority'])) {
  349. return 1;
  350. }
  352. if (!\is_int($a['priority']) && \is_int($b['priority'])) {
  353. return -1;
  354. }
  356. if ($a['priority'] === $b['priority']) {
  357. return 0;
  358. }
  360. if ($a['priority'] > $b['priority']) {
  361. return -1;
  362. }
  364. return 1;
  365. }
  366. }