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

  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\EventDispatcher;
  17. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  18. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpFoundation\RequestStack;
  21. use Symfony\Component\Stopwatch\Stopwatch;
  22. use Symfony\Contracts\Service\ResetInterface;
  24. /**
  25. * Collects some data about event listeners.
  26. *
  27. * This event dispatcher delegates the dispatching to another one.
  28. *
  29. * @author Fabien Potencier <fabien@symfony.com>
  30. */
  31. class TraceableEventDispatcher implements EventDispatcherInterface, ResetInterface
  32. {
  33. protected $logger;
  34. protected $stopwatch;
  36. /**
  37. * @var \SplObjectStorage<WrappedListener, array{string, string}>|null
  38. */
  39. private ?\SplObjectStorage $callStack = null;
  40. private EventDispatcherInterface $dispatcher;
  41. private array $wrappedListeners = [];
  42. private array $orphanedEvents = [];
  43. private array $dispatchDepth = [];
  44. private array $calledListenerInfos = [];
  45. private array $calledOriginalListeners = [];
  46. private ?RequestStack $requestStack;
  47. private string $currentRequestHash = '';
  49. public function __construct(EventDispatcherInterface $dispatcher, Stopwatch $stopwatch, ?LoggerInterface $logger = null, ?RequestStack $requestStack = null)
  50. {
  51. $this->dispatcher = $dispatcher;
  52. $this->stopwatch = $stopwatch;
  53. $this->logger = $logger;
  54. $this->requestStack = $requestStack;
  55. }
  57. /**
  58. * @return void
  59. */
  60. public function addListener(string $eventName, callable|array $listener, int $priority = 0)
  61. {
  62. $this->dispatcher->addListener($eventName, $listener, $priority);
  63. }
  65. /**
  66. * @return void
  67. */
  68. public function addSubscriber(EventSubscriberInterface $subscriber)
  69. {
  70. $this->dispatcher->addSubscriber($subscriber);
  71. }
  73. /**
  74. * @return void
  75. */
  76. public function removeListener(string $eventName, callable|array $listener)
  77. {
  78. if (isset($this->wrappedListeners[$eventName])) {
  79. foreach ($this->wrappedListeners[$eventName] as $index => $wrappedListener) {
  80. if ($wrappedListener->getWrappedListener() === $listener || ($listener instanceof \Closure && $wrappedListener->getWrappedListener() == $listener)) {
  81. $listener = $wrappedListener;
  82. unset($this->wrappedListeners[$eventName][$index]);
  83. break;
  84. }
  85. }
  86. }
  88. $this->dispatcher->removeListener($eventName, $listener);
  89. }
  91. /**
  92. * @return void
  93. */
  94. public function removeSubscriber(EventSubscriberInterface $subscriber)
  95. {
  96. $this->dispatcher->removeSubscriber($subscriber);
  97. }
  99. public function getListeners(?string $eventName = null): array
  100. {
  101. return $this->dispatcher->getListeners($eventName);
  102. }
  104. public function getListenerPriority(string $eventName, callable|array $listener): ?int
  105. {
  106. // we might have wrapped listeners for the event (if called while dispatching)
  107. // in that case get the priority by wrapper
  108. if (isset($this->wrappedListeners[$eventName])) {
  109. foreach ($this->wrappedListeners[$eventName] as $wrappedListener) {
  110. if ($wrappedListener->getWrappedListener() === $listener || ($listener instanceof \Closure && $wrappedListener->getWrappedListener() == $listener)) {
  111. return $this->dispatcher->getListenerPriority($eventName, $wrappedListener);
  112. }
  113. }
  114. }
  116. return $this->dispatcher->getListenerPriority($eventName, $listener);
  117. }
  119. public function hasListeners(?string $eventName = null): bool
  120. {
  121. return $this->dispatcher->hasListeners($eventName);
  122. }
  124. public function dispatch(object $event, ?string $eventName = null): object
  125. {
  126. $eventName ??= $event::class;
  128. $this->callStack ??= new \SplObjectStorage();
  130. $currentRequestHash = $this->currentRequestHash = $this->requestStack && ($request = $this->requestStack->getCurrentRequest()) ? spl_object_hash($request) : '';
  132. if (null !== $this->logger && $event instanceof StoppableEventInterface && $event->isPropagationStopped()) {
  133. $this->logger->debug(\sprintf('The "%s" event is already stopped. No listeners have been called.', $eventName));
  134. }
  136. $this->preProcess($eventName);
  137. try {
  138. $this->beforeDispatch($eventName, $event);
  139. try {
  140. $e = $this->stopwatch->start($eventName, 'section');
  141. try {
  142. $this->dispatcher->dispatch($event, $eventName);
  143. } finally {
  144. if ($e->isStarted()) {
  145. $e->stop();
  146. }
  147. }
  148. } finally {
  149. $this->afterDispatch($eventName, $event);
  150. }
  151. } finally {
  152. $this->currentRequestHash = $currentRequestHash;
  153. $this->postProcess($eventName);
  154. }
  156. return $event;
  157. }
  159. public function getCalledListeners(?Request $request = null): array
  160. {
  161. if (!$this->calledListenerInfos) {
  162. return [];
  163. }
  165. $hash = $request ? spl_object_hash($request) : null;
  166. $called = [];
  168. foreach ($this->calledListenerInfos as $requestHash => $infos) {
  169. if (null === $hash || $hash === $requestHash) {
  170. $called[] = $infos;
  171. }
  172. }
  174. return $called ? array_merge(...$called) : [];
  175. }
  177. public function getNotCalledListeners(?Request $request = null): array
  178. {
  179. try {
  180. $allListeners = $this->dispatcher instanceof EventDispatcher ? $this->getListenersWithPriority() : $this->getListenersWithoutPriority();
  181. } catch (\Exception $e) {
  182. $this->logger?->info('An exception was thrown while getting the uncalled listeners.', ['exception' => $e]);
  184. // unable to retrieve the uncalled listeners
  185. return [];
  186. }
  188. $hash = $request ? spl_object_hash($request) : null;
  189. $calledListeners = [];
  191. foreach ($this->calledOriginalListeners as $requestHash => $eventListeners) {
  192. if (null === $hash || $hash === $requestHash) {
  193. $calledListeners[] = array_merge(...array_values($eventListeners));
  194. }
  195. }
  197. $calledListeners = $calledListeners ? array_merge(...$calledListeners) : [];
  199. $notCalled = [];
  201. foreach ($allListeners as $eventName => $listeners) {
  202. foreach ($listeners as [$listener, $priority]) {
  203. if (!\in_array($listener, $calledListeners, true)) {
  204. if (!$listener instanceof WrappedListener) {
  205. $listener = new WrappedListener($listener, null, $this->stopwatch, $this, $priority);
  206. }
  207. $notCalled[] = $listener->getInfo($eventName);
  208. }
  209. }
  210. }
  212. uasort($notCalled, $this->sortNotCalledListeners(...));
  214. return $notCalled;
  215. }
  217. public function getOrphanedEvents(?Request $request = null): array
  218. {
  219. if ($request) {
  220. return $this->orphanedEvents[spl_object_hash($request)] ?? [];
  221. }
  223. if (!$this->orphanedEvents) {
  224. return [];
  225. }
  227. return array_merge(...array_values($this->orphanedEvents));
  228. }
  230. /**
  231. * @return void
  232. */
  233. public function reset()
  234. {
  235. $this->callStack = null;
  236. $this->orphanedEvents = [];
  237. $this->currentRequestHash = '';
  238. $this->dispatchDepth = [];
  239. $this->calledListenerInfos = [];
  240. $this->calledOriginalListeners = [];
  241. }
  243. /**
  244. * Proxies all method calls to the original event dispatcher.
  245. *
  246. * @param string $method The method name
  247. * @param array $arguments The method arguments
  248. */
  249. public function __call(string $method, array $arguments): mixed
  250. {
  251. return $this->dispatcher->{$method}(...$arguments);
  252. }
  254. /**
  255. * Called before dispatching the event.
  256. *
  257. * @return void
  258. */
  259. protected function beforeDispatch(string $eventName, object $event)
  260. {
  261. }
  263. /**
  264. * Called after dispatching the event.
  265. *
  266. * @return void
  267. */
  268. protected function afterDispatch(string $eventName, object $event)
  269. {
  270. }
  272. private function preProcess(string $eventName): void
  273. {
  274. $this->dispatchDepth[$eventName] = ($this->dispatchDepth[$eventName] ?? 0) + 1;
  276. if (!$this->dispatcher->hasListeners($eventName)) {
  277. $this->orphanedEvents[$this->currentRequestHash][] = $eventName;
  279. return;
  280. }
  282. foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  283. $priority = $this->getListenerPriority($eventName, $listener);
  284. $wrappedListener = new WrappedListener($listener instanceof WrappedListener ? $listener->getWrappedListener() : $listener, null, $this->stopwatch, $this);
  285. $this->wrappedListeners[$eventName][] = $wrappedListener;
  286. $this->dispatcher->removeListener($eventName, $listener);
  287. $this->dispatcher->addListener($eventName, $wrappedListener, $priority);
  288. $this->callStack[$wrappedListener] = [$eventName, $this->currentRequestHash];
  289. }
  290. }
  292. private function postProcess(string $eventName): void
  293. {
  294. --$this->dispatchDepth[$eventName];
  296. unset($this->wrappedListeners[$eventName]);
  297. $skipped = false;
  298. foreach ($this->dispatcher->getListeners($eventName) as $listener) {
  299. if (!$listener instanceof WrappedListener) { // #12845: a new listener was added during dispatch.
  300. continue;
  301. }
  302. // Unwrap listener
  303. $priority = $this->getListenerPriority($eventName, $listener);
  304. $this->dispatcher->removeListener($eventName, $listener);
  305. $this->dispatcher->addListener($eventName, $listener->getWrappedListener(), $priority);
  307. if (null !== $this->logger) {
  308. $context = ['event' => $eventName, 'listener' => $listener->getPretty()];
  309. }
  311. if ($listener->wasCalled()) {
  312. $this->logger?->debug('Notified event "{event}" to listener "{listener}".', $context);
  314. $original = $listener->getWrappedListener();
  315. if (!\in_array($original, $this->calledOriginalListeners[$this->currentRequestHash][$eventName] ?? [], true)) {
  316. $this->calledOriginalListeners[$this->currentRequestHash][$eventName][] = $original;
  317. $this->calledListenerInfos[$this->currentRequestHash][] = $listener->getInfo($eventName);
  318. }
  319. }
  321. unset($this->callStack[$listener]);
  323. if (null !== $this->logger && $skipped) {
  324. $this->logger->debug('Listener "{listener}" was not called for event "{event}".', $context);
  325. }
  327. if ($listener->stoppedPropagation()) {
  328. $this->logger?->debug('Listener "{listener}" stopped propagation of the event "{event}".', $context);
  330. $skipped = true;
  331. }
  332. }
  334. if (0 < $this->dispatchDepth[$eventName]) {
  335. return;
  336. }
  338. // Clean up stale callStack entries left by nested same-event dispatches
  339. $stale = [];
  340. foreach ($this->callStack as $listener) {
  341. if ($this->callStack->getInfo()[0] === $eventName) {
  342. $stale[] = $listener;
  343. }
  344. }
  345. foreach ($stale as $listener) {
  346. if ($listener->wasCalled()) {
  347. $original = $listener->getWrappedListener();
  348. if (!\in_array($original, $this->calledOriginalListeners[$this->currentRequestHash][$eventName] ?? [], true)) {
  349. $this->calledOriginalListeners[$this->currentRequestHash][$eventName][] = $original;
  350. $this->calledListenerInfos[$this->currentRequestHash][] = $listener->getInfo($eventName);
  351. }
  352. }
  353. unset($this->callStack[$listener]);
  354. }
  355. }
  357. private function sortNotCalledListeners(array $a, array $b): int
  358. {
  359. if (0 !== $cmp = strcmp($a['event'], $b['event'])) {
  360. return $cmp;
  361. }
  363. if (\is_int($a['priority']) && !\is_int($b['priority'])) {
  364. return 1;
  365. }
  367. if (!\is_int($a['priority']) && \is_int($b['priority'])) {
  368. return -1;
  369. }
  371. if ($a['priority'] === $b['priority']) {
  372. return 0;
  373. }
  375. if ($a['priority'] > $b['priority']) {
  376. return -1;
  377. }
  379. return 1;
  380. }
  382. private function getListenersWithPriority(): array
  383. {
  384. $result = [];
  386. $allListeners = new \ReflectionProperty(EventDispatcher::class, 'listeners');
  388. foreach ($allListeners->getValue($this->dispatcher) as $eventName => $listenersByPriority) {
  389. foreach ($listenersByPriority as $priority => $listeners) {
  390. foreach ($listeners as $listener) {
  391. $result[$eventName][] = [$listener, $priority];
  392. }
  393. }
  394. }
  396. return $result;
  397. }
  399. private function getListenersWithoutPriority(): array
  400. {
  401. $result = [];
  403. foreach ($this->getListeners() as $eventName => $listeners) {
  404. foreach ($listeners as $listener) {
  405. $result[$eventName][] = [$listener, null];
  406. }
  407. }
  409. return $result;
  410. }
  411. }