vendor\symfony\http-kernel\EventListener\DebugHandlersListener.php line 70

  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\HttpKernel\EventListener;
  14. use Psr\Log\LoggerInterface;
  15. use Symfony\Component\Console\ConsoleEvents;
  16. use Symfony\Component\Console\Event\ConsoleEvent;
  17. use Symfony\Component\Console\Output\ConsoleOutputInterface;
  18. use Symfony\Component\ErrorHandler\ErrorHandler;
  19. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  20. use Symfony\Component\HttpKernel\Event\KernelEvent;
  21. use Symfony\Component\HttpKernel\KernelEvents;
  23. /**
  24.  * Configures errors and exceptions handlers.
  25.  *
  26.  * @author Nicolas Grekas <p@tchwork.com>
  27.  *
  28.  * @final
  29.  *
  30.  * @internal
  31.  */
  32. class DebugHandlersListener implements EventSubscriberInterface
  33. {
  34.     private string|object|null $earlyHandler;
  35.     private ?\Closure $exceptionHandler;
  36.     private ?LoggerInterface $logger;
  37.     private ?LoggerInterface $deprecationLogger;
  38.     private array|int|null $levels;
  39.     private ?int $throwAt;
  40.     private bool $scream;
  41.     private bool $scope;
  42.     private bool $firstCall = true;
  43.     private bool $hasTerminatedWithException = false;
  45.     /**
  46.      * @param callable|null  $exceptionHandler A handler that must support \Throwable instances that will be called on Exception
  47.      * @param array|int|null $levels           An array map of E_* to LogLevel::* or an integer bit field of E_* constants
  48.      * @param int|null       $throwAt          Thrown errors in a bit field of E_* constants, or null to keep the current value
  49.      * @param bool           $scream           Enables/disables screaming mode, where even silenced errors are logged
  50.      * @param bool           $scope            Enables/disables scoping mode
  51.      */
  52.     public function __construct(callable $exceptionHandler = null, LoggerInterface $logger = null, array|int|null $levels = \E_ALL, ?int $throwAt = \E_ALL, bool $scream = true, bool $scope = true, LoggerInterface $deprecationLogger = null)
  53.     {
  54.         $handler = set_exception_handler('is_int');
  55.         $this->earlyHandler = \is_array($handler) ? $handler[0] : null;
  56.         restore_exception_handler();
  58.         $this->exceptionHandler = null === $exceptionHandler ? null : $exceptionHandler(...);
  59.         $this->logger = $logger;
  60.         $this->levels = $levels ?? \E_ALL;
  61.         $this->throwAt = \is_int($throwAt) ? $throwAt : (null === $throwAt ? null : ($throwAt ? \E_ALL : null));
  62.         $this->scream = $scream;
  63.         $this->scope = $scope;
  64.         $this->deprecationLogger = $deprecationLogger;
  65.     }
  67.     /**
  68.      * Configures the error handler.
  69.      */
  70.     public function configure(object $event = null)
  71.     {
  72.         if ($event instanceof ConsoleEvent && !\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true)) {
  73.             return;
  74.         }
  75.         if (!$event instanceof KernelEvent ? !$this->firstCall : !$event->isMainRequest()) {
  76.             return;
  77.         }
  78.         $this->firstCall = $this->hasTerminatedWithException = false;
  80.         $handler = set_exception_handler('is_int');
  81.         $handler = \is_array($handler) ? $handler[0] : null;
  82.         restore_exception_handler();
  84.         if (!$handler instanceof ErrorHandler) {
  85.             $handler = $this->earlyHandler;
  86.         }
  88.         if ($handler instanceof ErrorHandler) {
  89.             if ($this->logger || $this->deprecationLogger) {
  90.                 $this->setDefaultLoggers($handler);
  91.                 if (\is_array($this->levels)) {
  92.                     $levels = 0;
  93.                     foreach ($this->levels as $type => $log) {
  94.                         $levels |= $type;
  95.                     }
  96.                 } else {
  97.                     $levels = $this->levels;
  98.                 }
  100.                 if ($this->scream) {
  101.                     $handler->screamAt($levels);
  102.                 }
  103.                 if ($this->scope) {
  104.                     $handler->scopeAt($levels & ~\E_USER_DEPRECATED & ~\E_DEPRECATED);
  105.                 } else {
  106.                     $handler->scopeAt(0, true);
  107.                 }
  108.                 $this->logger = $this->deprecationLogger = $this->levels = null;
  109.             }
  110.             if (null !== $this->throwAt) {
  111.                 $handler->throwAt($this->throwAt, true);
  112.             }
  113.         }
  114.         if (!$this->exceptionHandler) {
  115.             if ($event instanceof KernelEvent) {
  116.                 if (method_exists($kernel = $event->getKernel(), 'terminateWithException')) {
  117.                     $request = $event->getRequest();
  118.                     $hasRun = &$this->hasTerminatedWithException;
  119.                     $this->exceptionHandler = static function (\Throwable $e) use ($kernel, $request, &$hasRun) {
  120.                         if ($hasRun) {
  121.                             throw $e;
  122.                         }
  124.                         $hasRun = true;
  125.                         $kernel->terminateWithException($e, $request);
  126.                     };
  127.                 }
  128.             } elseif ($event instanceof ConsoleEvent && $app = $event->getCommand()->getApplication()) {
  129.                 $output = $event->getOutput();
  130.                 if ($output instanceof ConsoleOutputInterface) {
  131.                     $output = $output->getErrorOutput();
  132.                 }
  133.                 $this->exceptionHandler = static function (\Throwable $e) use ($app, $output) {
  134.                     $app->renderThrowable($e, $output);
  135.                 };
  136.             }
  137.         }
  138.         if ($this->exceptionHandler) {
  139.             if ($handler instanceof ErrorHandler) {
  140.                 $handler->setExceptionHandler($this->exceptionHandler);
  141.             }
  142.             $this->exceptionHandler = null;
  143.         }
  144.     }
  146.     private function setDefaultLoggers(ErrorHandler $handler): void
  147.     {
  148.         if (\is_array($this->levels)) {
  149.             $levelsDeprecatedOnly = [];
  150.             $levelsWithoutDeprecated = [];
  151.             foreach ($this->levels as $type => $log) {
  152.                 if (\E_DEPRECATED == $type || \E_USER_DEPRECATED == $type) {
  153.                     $levelsDeprecatedOnly[$type] = $log;
  154.                 } else {
  155.                     $levelsWithoutDeprecated[$type] = $log;
  156.                 }
  157.             }
  158.         } else {
  159.             $levelsDeprecatedOnly = $this->levels & (\E_DEPRECATED | \E_USER_DEPRECATED);
  160.             $levelsWithoutDeprecated = $this->levels & ~\E_DEPRECATED & ~\E_USER_DEPRECATED;
  161.         }
  163.         $defaultLoggerLevels = $this->levels;
  164.         if ($this->deprecationLogger && $levelsDeprecatedOnly) {
  165.             $handler->setDefaultLogger($this->deprecationLogger, $levelsDeprecatedOnly);
  166.             $defaultLoggerLevels = $levelsWithoutDeprecated;
  167.         }
  169.         if ($this->logger && $defaultLoggerLevels) {
  170.             $handler->setDefaultLogger($this->logger, $defaultLoggerLevels);
  171.         }
  172.     }
  174.     public static function getSubscribedEvents(): array
  175.     {
  176.         $events = [KernelEvents::REQUEST => ['configure', 2048]];
  178.         if (\defined('Symfony\Component\Console\ConsoleEvents::COMMAND')) {
  179.             $events[ConsoleEvents::COMMAND] = ['configure', 2048];
  180.         }
  182.         return $events;
  183.     }
  184. }