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

  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. /**
  37. * @param array<class-string, array{log_level: string|null, status_code: int<100,599>|null}> $exceptionsMapping
  38. */
  39. public function __construct(
  40. protected string|object|array|null $controller,
  41. protected ?LoggerInterface $logger = null,
  42. protected bool $debug = false,
  43. protected array $exceptionsMapping = [],
  44. ) {
  45. }
  47. public function logKernelException(ExceptionEvent $event): void
  48. {
  49. $throwable = $event->getThrowable();
  50. $logLevel = $this->resolveLogLevel($throwable);
  52. foreach ($this->exceptionsMapping as $class => $config) {
  53. if (!$throwable instanceof $class || !$config['status_code']) {
  54. continue;
  55. }
  56. if (!$throwable instanceof HttpExceptionInterface || $throwable->getStatusCode() !== $config['status_code']) {
  57. $headers = $throwable instanceof HttpExceptionInterface ? $throwable->getHeaders() : [];
  58. $throwable = HttpException::fromStatusCode($config['status_code'], $throwable->getMessage(), $throwable, $headers);
  59. $event->setThrowable($throwable);
  60. }
  61. break;
  62. }
  64. // There's no specific status code defined in the configuration for this exception
  65. if (!$throwable instanceof HttpExceptionInterface && $withHttpStatus = $this->getInheritedAttribute($throwable::class, WithHttpStatus::class)) {
  66. $throwable = HttpException::fromStatusCode($withHttpStatus->statusCode, $throwable->getMessage(), $throwable, $withHttpStatus->headers);
  67. $event->setThrowable($throwable);
  68. }
  70. $e = FlattenException::createFromThrowable($throwable);
  72. $this->logException($throwable, sprintf('Uncaught PHP Exception %s: "%s" at %s line %s', $e->getClass(), $e->getMessage(), basename($e->getFile()), $e->getLine()), $logLevel);
  73. }
  75. public function onKernelException(ExceptionEvent $event): void
  76. {
  77. if (null === $this->controller) {
  78. return;
  79. }
  81. if (!$this->debug && $event->isKernelTerminating()) {
  82. return;
  83. }
  85. $throwable = $event->getThrowable();
  87. $exceptionHandler = set_exception_handler('var_dump');
  88. restore_exception_handler();
  90. if (\is_array($exceptionHandler) && $exceptionHandler[0] instanceof ErrorHandler) {
  91. $throwable = $exceptionHandler[0]->enhanceError($event->getThrowable());
  92. }
  94. $request = $this->duplicateRequest($throwable, $event->getRequest());
  96. try {
  97. $response = $event->getKernel()->handle($request, HttpKernelInterface::SUB_REQUEST, false);
  98. } catch (\Exception $e) {
  99. $f = FlattenException::createFromThrowable($e);
  101. $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()));
  103. $prev = $e;
  104. do {
  105. if ($throwable === $wrapper = $prev) {
  106. throw $e;
  107. }
  108. } while ($prev = $wrapper->getPrevious());
  110. $prev = new \ReflectionProperty($wrapper instanceof \Exception ? \Exception::class : \Error::class, 'previous');
  111. $prev->setValue($wrapper, $throwable);
  113. throw $e;
  114. }
  116. $event->setResponse($response);
  118. if ($this->debug) {
  119. $event->getRequest()->attributes->set('_remove_csp_headers', true);
  120. }
  121. }
  123. public function removeCspHeader(ResponseEvent $event): void
  124. {
  125. if ($this->debug && $event->getRequest()->attributes->get('_remove_csp_headers', false)) {
  126. $event->getResponse()->headers->remove('Content-Security-Policy');
  127. }
  128. }
  130. public function onControllerArguments(ControllerArgumentsEvent $event): void
  131. {
  132. $e = $event->getRequest()->attributes->get('exception');
  134. if (!$e instanceof \Throwable || false === $k = array_search($e, $event->getArguments(), true)) {
  135. return;
  136. }
  138. $r = new \ReflectionFunction($event->getController()(...));
  139. $r = $r->getParameters()[$k] ?? null;
  141. if ($r && (!($r = $r->getType()) instanceof \ReflectionNamedType || FlattenException::class === $r->getName())) {
  142. $arguments = $event->getArguments();
  143. $arguments[$k] = FlattenException::createFromThrowable($e);
  144. $event->setArguments($arguments);
  145. }
  146. }
  148. public static function getSubscribedEvents(): array
  149. {
  150. return [
  151. KernelEvents::CONTROLLER_ARGUMENTS => 'onControllerArguments',
  152. KernelEvents::EXCEPTION => [
  153. ['logKernelException', 0],
  154. ['onKernelException', -128],
  155. ],
  156. KernelEvents::RESPONSE => ['removeCspHeader', -128],
  157. ];
  158. }
  160. /**
  161. * Logs an exception.
  162. */
  163. protected function logException(\Throwable $exception, string $message, ?string $logLevel = null): void
  164. {
  165. if (null === $this->logger) {
  166. return;
  167. }
  169. $logLevel ??= $this->resolveLogLevel($exception);
  171. $this->logger->log($logLevel, $message, ['exception' => $exception]);
  172. }
  174. /**
  175. * Resolves the level to be used when logging the exception.
  176. */
  177. private function resolveLogLevel(\Throwable $throwable): string
  178. {
  179. foreach ($this->exceptionsMapping as $class => $config) {
  180. if ($throwable instanceof $class && $config['log_level']) {
  181. return $config['log_level'];
  182. }
  183. }
  185. if ($withLogLevel = $this->getInheritedAttribute($throwable::class, WithLogLevel::class)) {
  186. return $withLogLevel->level;
  187. }
  189. if (!$throwable instanceof HttpExceptionInterface || $throwable->getStatusCode() >= 500) {
  190. return LogLevel::CRITICAL;
  191. }
  193. return LogLevel::ERROR;
  194. }
  196. /**
  197. * Clones the request for the exception.
  198. */
  199. protected function duplicateRequest(\Throwable $exception, Request $request): Request
  200. {
  201. $attributes = [
  202. '_controller' => $this->controller,
  203. 'exception' => $exception,
  204. 'logger' => DebugLoggerConfigurator::getDebugLogger($this->logger),
  205. ];
  206. $request = $request->duplicate(null, null, $attributes);
  207. $request->setMethod('GET');
  209. return $request;
  210. }
  212. /**
  213. * @template T
  214. *
  215. * @param class-string<T> $attribute
  216. *
  217. * @return T|null
  218. */
  219. private function getInheritedAttribute(string $class, string $attribute): ?object
  220. {
  221. $class = new \ReflectionClass($class);
  222. $interfaces = [];
  223. $attributeReflector = null;
  224. $parentInterfaces = [];
  225. $ownInterfaces = [];
  227. do {
  228. if ($attributes = $class->getAttributes($attribute, \ReflectionAttribute::IS_INSTANCEOF)) {
  229. $attributeReflector = $attributes[0];
  230. $parentInterfaces = class_implements($class->name);
  231. break;
  232. }
  234. $interfaces[] = class_implements($class->name);
  235. } while ($class = $class->getParentClass());
  237. while ($interfaces) {
  238. $ownInterfaces = array_diff_key(array_pop($interfaces), $parentInterfaces);
  239. $parentInterfaces += $ownInterfaces;
  241. foreach ($ownInterfaces as $interface) {
  242. $class = new \ReflectionClass($interface);
  244. if ($attributes = $class->getAttributes($attribute, \ReflectionAttribute::IS_INSTANCEOF)) {
  245. $attributeReflector = $attributes[0];
  246. }
  247. }
  248. }
  250. return $attributeReflector?->newInstance();
  251. }
  252. }