vendor\symfony\http-kernel\EventListener\ErrorListener.php line 123

  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\ErrorHandler\Exception\FlattenException;
  16. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  17. use Symfony\Component\HttpFoundation\Request;
  18. use Symfony\Component\HttpKernel\Event\ControllerArgumentsEvent;
  19. use Symfony\Component\HttpKernel\Event\ExceptionEvent;
  20. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  21. use Symfony\Component\HttpKernel\Exception\HttpException;
  22. use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
  23. use Symfony\Component\HttpKernel\HttpKernelInterface;
  24. use Symfony\Component\HttpKernel\KernelEvents;
  25. use Symfony\Component\HttpKernel\Log\DebugLoggerInterface;
  27. /**
  28.  * @author Fabien Potencier <fabien@symfony.com>
  29.  */
  30. class ErrorListener implements EventSubscriberInterface
  31. {
  32.     protected $controller;
  33.     protected $logger;
  34.     protected $debug;
  35.     /**
  36.      * @var array<class-string, array{log_level: string|null, status_code: int<100,599>|null}>
  37.      */
  38.     protected $exceptionsMapping;
  40.     /**
  41.      * @param array<class-string, array{log_level: string|null, status_code: int<100,599>|null}> $exceptionsMapping
  42.      */
  43.     public function __construct(string|object|array|null $controller, LoggerInterface $logger = null, bool $debug = false, array $exceptionsMapping = [])
  44.     {
  45.         $this->controller = $controller;
  46.         $this->logger = $logger;
  47.         $this->debug = $debug;
  48.         $this->exceptionsMapping = $exceptionsMapping;
  49.     }
  51.     public function logKernelException(ExceptionEvent $event)
  52.     {
  53.         $throwable = $event->getThrowable();
  54.         $logLevel = null;
  56.         foreach ($this->exceptionsMapping as $class => $config) {
  57.             if ($throwable instanceof $class && $config['log_level']) {
  58.                 $logLevel = $config['log_level'];
  59.                 break;
  60.             }
  61.         }
  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.         $e = FlattenException::createFromThrowable($throwable);
  77.         $this->logException($throwable, sprintf('Uncaught PHP Exception %s: "%s" at %s line %s', $e->getClass(), $e->getMessage(), $e->getFile(), $e->getLine()), $logLevel);
  78.     }
  80.     public function onKernelException(ExceptionEvent $event)
  81.     {
  82.         if (null === $this->controller) {
  83.             return;
  84.         }
  86.         $throwable = $event->getThrowable();
  87.         $request = $this->duplicateRequest($throwable, $event->getRequest());
  89.         try {
  90.             $response = $event->getKernel()->handle($request, HttpKernelInterface::SUB_REQUEST, false);
  91.         } catch (\Exception $e) {
  92.             $f = FlattenException::createFromThrowable($e);
  94.             $this->logException($e, sprintf('Exception thrown when handling an exception (%s: %s at %s line %s)', $f->getClass(), $f->getMessage(), $e->getFile(), $e->getLine()));
  96.             $prev = $e;
  97.             do {
  98.                 if ($throwable === $wrapper = $prev) {
  99.                     throw $e;
  100.                 }
  101.             } while ($prev = $wrapper->getPrevious());
  103.             $prev = new \ReflectionProperty($wrapper instanceof \Exception ? \Exception::class : \Error::class, 'previous');
  104.             $prev->setValue($wrapper, $throwable);
  106.             throw $e;
  107.         }
  109.         $event->setResponse($response);
  111.         if ($this->debug) {
  112.             $event->getRequest()->attributes->set('_remove_csp_headers', true);
  113.         }
  114.     }
  116.     public function removeCspHeader(ResponseEvent $event): void
  117.     {
  118.         if ($this->debug && $event->getRequest()->attributes->get('_remove_csp_headers', false)) {
  119.             $event->getResponse()->headers->remove('Content-Security-Policy');
  120.         }
  121.     }
  123.     public function onControllerArguments(ControllerArgumentsEvent $event)
  124.     {
  125.         $e = $event->getRequest()->attributes->get('exception');
  127.         if (!$e instanceof \Throwable || false === $k = array_search($e, $event->getArguments(), true)) {
  128.             return;
  129.         }
  131.         $r = new \ReflectionFunction($event->getController()(...));
  132.         $r = $r->getParameters()[$k] ?? null;
  134.         if ($r && (!($r = $r->getType()) instanceof \ReflectionNamedType || FlattenException::class === $r->getName())) {
  135.             $arguments = $event->getArguments();
  136.             $arguments[$k] = FlattenException::createFromThrowable($e);
  137.             $event->setArguments($arguments);
  138.         }
  139.     }
  141.     public static function getSubscribedEvents(): array
  142.     {
  143.         return [
  144.             KernelEvents::CONTROLLER_ARGUMENTS => 'onControllerArguments',
  145.             KernelEvents::EXCEPTION => [
  146.                 ['logKernelException', 0],
  147.                 ['onKernelException', -128],
  148.             ],
  149.             KernelEvents::RESPONSE => ['removeCspHeader', -128],
  150.         ];
  151.     }
  153.     /**
  154.      * Logs an exception.
  155.      */
  156.     protected function logException(\Throwable $exception, string $message, string $logLevel = null): void
  157.     {
  158.         if (null !== $this->logger) {
  159.             if (null !== $logLevel) {
  160.                 $this->logger->log($logLevel, $message, ['exception' => $exception]);
  161.             } elseif (!$exception instanceof HttpExceptionInterface || $exception->getStatusCode() >= 500) {
  162.                 $this->logger->critical($message, ['exception' => $exception]);
  163.             } else {
  164.                 $this->logger->error($message, ['exception' => $exception]);
  165.             }
  166.         }
  167.     }
  169.     /**
  170.      * Clones the request for the exception.
  171.      */
  172.     protected function duplicateRequest(\Throwable $exception, Request $request): Request
  173.     {
  174.         $attributes = [
  175.             '_controller' => $this->controller,
  176.             'exception' => $exception,
  177.             'logger' => $this->logger instanceof DebugLoggerInterface ? $this->logger : null,
  178.         ];
  179.         $request = $request->duplicate(null, null, $attributes);
  180.         $request->setMethod('GET');
  182.         return $request;
  183.     }
  184. }