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

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\HttpKernel\EventListener;
  11. use Psr\Log\LoggerInterface;
  12. use Symfony\Component\Debug\Exception\FlattenException as LegacyFlattenException;
  13. use Symfony\Component\ErrorHandler\Exception\FlattenException;
  14. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpKernel\Event\ControllerArgumentsEvent;
  17. use Symfony\Component\HttpKernel\Event\ExceptionEvent;
  18. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  19. use Symfony\Component\HttpKernel\Exception\HttpException;
  20. use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
  21. use Symfony\Component\HttpKernel\HttpKernelInterface;
  22. use Symfony\Component\HttpKernel\KernelEvents;
  23. use Symfony\Component\HttpKernel\Log\DebugLoggerInterface;
  24. /**
  25.  * @author Fabien Potencier <fabien@symfony.com>
  26.  */
  27. class ErrorListener implements EventSubscriberInterface
  28. {
  29.     protected $controller;
  30.     protected $logger;
  31.     protected $debug;
  32.     protected $exceptionsMapping;
  33.     public function __construct($controllerLoggerInterface $logger nullbool $debug false, array $exceptionsMapping = [])
  34.     {
  35.         $this->controller $controller;
  36.         $this->logger $logger;
  37.         $this->debug $debug;
  38.         $this->exceptionsMapping $exceptionsMapping;
  39.     }
  40.     public function logKernelException(ExceptionEvent $event)
  41.     {
  42.         $throwable $event->getThrowable();
  43.         $logLevel null;
  44.         foreach ($this->exceptionsMapping as $class => $config) {
  45.             if ($throwable instanceof $class && $config['log_level']) {
  46.                 $logLevel $config['log_level'];
  47.                 break;
  48.             }
  49.         }
  50.         foreach ($this->exceptionsMapping as $class => $config) {
  51.             if (!$throwable instanceof $class || !$config['status_code']) {
  52.                 continue;
  53.             }
  54.             if (!$throwable instanceof HttpExceptionInterface || $throwable->getStatusCode() !== $config['status_code']) {
  55.                 $headers $throwable instanceof HttpExceptionInterface $throwable->getHeaders() : [];
  56.                 $throwable = new HttpException($config['status_code'], $throwable->getMessage(), $throwable$headers);
  57.                 $event->setThrowable($throwable);
  58.             }
  59.             break;
  60.         }
  61.         $e FlattenException::createFromThrowable($throwable);
  62.         $this->logException($throwablesprintf('Uncaught PHP Exception %s: "%s" at %s line %s'$e->getClass(), $e->getMessage(), $e->getFile(), $e->getLine()), $logLevel);
  63.     }
  64.     public function onKernelException(ExceptionEvent $event)
  65.     {
  66.         if (null === $this->controller) {
  67.             return;
  68.         }
  69.         $throwable $event->getThrowable();
  70.         $request $this->duplicateRequest($throwable$event->getRequest());
  71.         try {
  72.             $response $event->getKernel()->handle($requestHttpKernelInterface::SUB_REQUESTfalse);
  73.         } catch (\Exception $e) {
  74.             $f FlattenException::createFromThrowable($e);
  75.             $this->logException($esprintf('Exception thrown when handling an exception (%s: %s at %s line %s)'$f->getClass(), $f->getMessage(), $e->getFile(), $e->getLine()));
  76.             $prev $e;
  77.             do {
  78.                 if ($throwable === $wrapper $prev) {
  79.                     throw $e;
  80.                 }
  81.             } while ($prev $wrapper->getPrevious());
  82.             $prev = new \ReflectionProperty($wrapper instanceof \Exception \Exception::class : \Error::class, 'previous');
  83.             $prev->setAccessible(true);
  84.             $prev->setValue($wrapper$throwable);
  85.             throw $e;
  86.         }
  87.         $event->setResponse($response);
  88.         if ($this->debug) {
  89.             $event->getRequest()->attributes->set('_remove_csp_headers'true);
  90.         }
  91.     }
  92.     public function removeCspHeader(ResponseEvent $event): void
  93.     {
  94.         if ($this->debug && $event->getRequest()->attributes->get('_remove_csp_headers'false)) {
  95.             $event->getResponse()->headers->remove('Content-Security-Policy');
  96.         }
  97.     }
  98.     public function onControllerArguments(ControllerArgumentsEvent $event)
  99.     {
  100.         $e $event->getRequest()->attributes->get('exception');
  101.         if (!$e instanceof \Throwable || false === $k array_search($e$event->getArguments(), true)) {
  102.             return;
  103.         }
  104.         $r = new \ReflectionFunction(\Closure::fromCallable($event->getController()));
  105.         $r $r->getParameters()[$k] ?? null;
  106.         if ($r && (!($r $r->getType()) instanceof \ReflectionNamedType || \in_array($r->getName(), [FlattenException::class, LegacyFlattenException::class], true))) {
  107.             $arguments $event->getArguments();
  108.             $arguments[$k] = FlattenException::createFromThrowable($e);
  109.             $event->setArguments($arguments);
  110.         }
  111.     }
  112.     public static function getSubscribedEvents(): array
  113.     {
  114.         return [
  115.             KernelEvents::CONTROLLER_ARGUMENTS => 'onControllerArguments',
  116.             KernelEvents::EXCEPTION => [
  117.                 ['logKernelException'0],
  118.                 ['onKernelException', -128],
  119.             ],
  120.             KernelEvents::RESPONSE => ['removeCspHeader', -128],
  121.         ];
  122.     }
  123.     /**
  124.      * Logs an exception.
  125.      */
  126.     protected function logException(\Throwable $exceptionstring $messagestring $logLevel null): void
  127.     {
  128.         if (null !== $this->logger) {
  129.             if (null !== $logLevel) {
  130.                 $this->logger->log($logLevel$message, ['exception' => $exception]);
  131.             } elseif (!$exception instanceof HttpExceptionInterface || $exception->getStatusCode() >= 500) {
  132.                 $this->logger->critical($message, ['exception' => $exception]);
  133.             } else {
  134.                 $this->logger->error($message, ['exception' => $exception]);
  135.             }
  136.         }
  137.     }
  138.     /**
  139.      * Clones the request for the exception.
  140.      */
  141.     protected function duplicateRequest(\Throwable $exceptionRequest $request): Request
  142.     {
  143.         $attributes = [
  144.             '_controller' => $this->controller,
  145.             'exception' => $exception,
  146.             'logger' => $this->logger instanceof DebugLoggerInterface $this->logger null,
  147.         ];
  148.         $request $request->duplicate(nullnull$attributes);
  149.         $request->setMethod('GET');
  150.         return $request;
  151.     }
  152. }