vendor/symfony/http-kernel/EventListener/ErrorListener.php line 46

  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 Psr\Log\LogLevel;
  16. use Symfony\Component\ErrorHandler\ErrorHandler;
  17. use Symfony\Component\ErrorHandler\Exception\FlattenException;
  18. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpKernel\Attribute\WithHttpStatus;
  21. use Symfony\Component\HttpKernel\Attribute\WithLogLevel;
  22. use Symfony\Component\HttpKernel\Event\ControllerArgumentsEvent;
  23. use Symfony\Component\HttpKernel\Event\ExceptionEvent;
  24. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  25. use Symfony\Component\HttpKernel\Exception\HttpException;
  26. use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
  27. use Symfony\Component\HttpKernel\HttpKernelInterface;
  28. use Symfony\Component\HttpKernel\KernelEvents;
  29. use Symfony\Component\HttpKernel\Log\DebugLoggerConfigurator;
  31. /**
  32.  * @author Fabien Potencier <fabien@symfony.com>
  33.  */
  34. class ErrorListener implements EventSubscriberInterface
  35. {
  36.     protected $controller;
  37.     protected $logger;
  38.     protected $debug;
  39.     /**
  40.      * @var array<class-string, array{log_level: string|null, status_code: int<100,599>|null}>
  41.      */
  42.     protected $exceptionsMapping;
  44.     /**
  45.      * @param array<class-string, array{log_level: string|null, status_code: int<100,599>|null}> $exceptionsMapping
  46.      */
  47.     public function __construct(string|object|array|null $controller, ?LoggerInterface $logger = null, bool $debug = false, array $exceptionsMapping = [])
  48.     {
  49.         $this->controller = $controller;
  50.         $this->logger = $logger;
  51.         $this->debug = $debug;
  52.         $this->exceptionsMapping = $exceptionsMapping;
  53.     }
  55.     /**
  56.      * @return void
  57.      */
  58.     public function logKernelException(ExceptionEvent $event)
  59.     {
  60.         $throwable = $event->getThrowable();
  61.         $logLevel = $this->resolveLogLevel($throwable);
  63.         foreach ($this->exceptionsMapping as $class => $config) {
  64.             if (!$throwable instanceof $class || !$config['status_code']) {
  65.                 continue;
  66.             }
  67.             if (!$throwable instanceof HttpExceptionInterface || $throwable->getStatusCode() !== $config['status_code']) {
  68.                 $headers = $throwable instanceof HttpExceptionInterface ? $throwable->getHeaders() : [];
  69.                 $throwable = new HttpException($config['status_code'], $throwable->getMessage(), $throwable, $headers);
  70.                 $event->setThrowable($throwable);
  71.             }
  72.             break;
  73.         }
  75.         // There's no specific status code defined in the configuration for this exception
  76.         if (!$throwable instanceof HttpExceptionInterface) {
  77.             $class = new \ReflectionClass($throwable);
  79.             do {
  80.                 if ($attributes = $class->getAttributes(WithHttpStatus::class, \ReflectionAttribute::IS_INSTANCEOF)) {
  81.                     /** @var WithHttpStatus $instance */
  82.                     $instance = $attributes[0]->newInstance();
  84.                     $throwable = new HttpException($instance->statusCode, $throwable->getMessage(), $throwable, $instance->headers);
  85.                     $event->setThrowable($throwable);
  86.                     break;
  87.                 }
  88.             } while ($class = $class->getParentClass());
  89.         }
  91.         $e = FlattenException::createFromThrowable($throwable);
  93.         $this->logException($throwable, sprintf('Uncaught PHP Exception %s: "%s" at %s line %s', $e->getClass(), $e->getMessage(), basename($e->getFile()), $e->getLine()), $logLevel);
  94.     }
  96.     /**
  97.      * @return void
  98.      */
  99.     public function onKernelException(ExceptionEvent $event)
  100.     {
  101.         if (null === $this->controller) {
  102.             return;
  103.         }
  105.         $throwable = $event->getThrowable();
  107.         if ($exceptionHandler = set_exception_handler(var_dump(...))) {
  108.             restore_exception_handler();
  109.             if (\is_array($exceptionHandler) && $exceptionHandler[0] instanceof ErrorHandler) {
  110.                 $throwable = $exceptionHandler[0]->enhanceError($event->getThrowable());
  111.             }
  112.         }
  114.         $request = $this->duplicateRequest($throwable, $event->getRequest());
  116.         try {
  117.             $response = $event->getKernel()->handle($request, HttpKernelInterface::SUB_REQUEST, false);
  118.         } catch (\Exception $e) {
  119.             $f = FlattenException::createFromThrowable($e);
  121.             $this->logException($e, sprintf('Exception thrown when handling an exception (%s: %s at %s line %s)', $f->getClass(), $f->getMessage(), basename($e->getFile()), $e->getLine()));
  123.             $prev = $e;
  124.             do {
  125.                 if ($throwable === $wrapper = $prev) {
  126.                     throw $e;
  127.                 }
  128.             } while ($prev = $wrapper->getPrevious());
  130.             $prev = new \ReflectionProperty($wrapper instanceof \Exception ? \Exception::class : \Error::class, 'previous');
  131.             $prev->setValue($wrapper, $throwable);
  133.             throw $e;
  134.         }
  136.         $event->setResponse($response);
  138.         if ($this->debug) {
  139.             $event->getRequest()->attributes->set('_remove_csp_headers', true);
  140.         }
  141.     }
  143.     public function removeCspHeader(ResponseEvent $event): void
  144.     {
  145.         if ($this->debug && $event->getRequest()->attributes->get('_remove_csp_headers', false)) {
  146.             $event->getResponse()->headers->remove('Content-Security-Policy');
  147.         }
  148.     }
  150.     /**
  151.      * @return void
  152.      */
  153.     public function onControllerArguments(ControllerArgumentsEvent $event)
  154.     {
  155.         $e = $event->getRequest()->attributes->get('exception');
  157.         if (!$e instanceof \Throwable || false === $k = array_search($e, $event->getArguments(), true)) {
  158.             return;
  159.         }
  161.         $r = new \ReflectionFunction($event->getController()(...));
  162.         $r = $r->getParameters()[$k] ?? null;
  164.         if ($r && (!($r = $r->getType()) instanceof \ReflectionNamedType || FlattenException::class === $r->getName())) {
  165.             $arguments = $event->getArguments();
  166.             $arguments[$k] = FlattenException::createFromThrowable($e);
  167.             $event->setArguments($arguments);
  168.         }
  169.     }
  171.     public static function getSubscribedEvents(): array
  172.     {
  173.         return [
  174.             KernelEvents::CONTROLLER_ARGUMENTS => 'onControllerArguments',
  175.             KernelEvents::EXCEPTION => [
  176.                 ['logKernelException', 0],
  177.                 ['onKernelException', -128],
  178.             ],
  179.             KernelEvents::RESPONSE => ['removeCspHeader', -128],
  180.         ];
  181.     }
  183.     /**
  184.      * Logs an exception.
  185.      */
  186.     protected function logException(\Throwable $exception, string $message, ?string $logLevel = null): void
  187.     {
  188.         if (null === $this->logger) {
  189.             return;
  190.         }
  192.         $logLevel ??= $this->resolveLogLevel($exception);
  194.         $this->logger->log($logLevel, $message, ['exception' => $exception]);
  195.     }
  197.     /**
  198.      * Resolves the level to be used when logging the exception.
  199.      */
  200.     private function resolveLogLevel(\Throwable $throwable): string
  201.     {
  202.         foreach ($this->exceptionsMapping as $class => $config) {
  203.             if ($throwable instanceof $class && $config['log_level']) {
  204.                 return $config['log_level'];
  205.             }
  206.         }
  208.         $class = new \ReflectionClass($throwable);
  210.         do {
  211.             if ($attributes = $class->getAttributes(WithLogLevel::class)) {
  212.                 /** @var WithLogLevel $instance */
  213.                 $instance = $attributes[0]->newInstance();
  215.                 return $instance->level;
  216.             }
  217.         } while ($class = $class->getParentClass());
  219.         if (!$throwable instanceof HttpExceptionInterface || $throwable->getStatusCode() >= 500) {
  220.             return LogLevel::CRITICAL;
  221.         }
  223.         return LogLevel::ERROR;
  224.     }
  226.     /**
  227.      * Clones the request for the exception.
  228.      */
  229.     protected function duplicateRequest(\Throwable $exception, Request $request): Request
  230.     {
  231.         $attributes = [
  232.             '_controller' => $this->controller,
  233.             'exception' => $exception,
  234.             'logger' => DebugLoggerConfigurator::getDebugLogger($this->logger),
  235.         ];
  236.         $request = $request->duplicate(null, null, $attributes);
  237.         $request->setMethod('GET');
  239.         return $request;
  240.     }
  241. }