vendor/symfony/error-handler/Exception/FlattenException.php line 25

  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\ErrorHandler\Exception;
  14. use Symfony\Component\HttpFoundation\Exception\RequestExceptionInterface;
  15. use Symfony\Component\HttpFoundation\Response;
  16. use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;
  18. /**
  19.  * FlattenException wraps a PHP Error or Exception to be able to serialize it.
  20.  *
  21.  * Basically, this class removes all objects from the trace.
  22.  *
  23.  * @author Fabien Potencier <fabien@symfony.com>
  24.  */
  25. class FlattenException
  26. {
  27.     private string $message;
  28.     private string|int $code;
  29.     private ?self $previous = null;
  30.     private array $trace;
  31.     private string $traceAsString;
  32.     private string $class;
  33.     private int $statusCode;
  34.     private string $statusText;
  35.     private array $headers;
  36.     private string $file;
  37.     private int $line;
  38.     private ?string $asString = null;
  40.     public static function create(\Exception $exception, int $statusCode = null, array $headers = []): static
  41.     {
  42.         return static::createFromThrowable($exception, $statusCode, $headers);
  43.     }
  45.     public static function createFromThrowable(\Throwable $exception, int $statusCode = null, array $headers = []): static
  46.     {
  47.         $e = new static();
  48.         $e->setMessage($exception->getMessage());
  49.         $e->setCode($exception->getCode());
  51.         if ($exception instanceof HttpExceptionInterface) {
  52.             $statusCode = $exception->getStatusCode();
  53.             $headers = array_merge($headers, $exception->getHeaders());
  54.         } elseif ($exception instanceof RequestExceptionInterface) {
  55.             $statusCode = 400;
  56.         }
  58.         $statusCode ??= 500;
  60.         if (class_exists(Response::class) && isset(Response::$statusTexts[$statusCode])) {
  61.             $statusText = Response::$statusTexts[$statusCode];
  62.         } else {
  63.             $statusText = 'Whoops, looks like something went wrong.';
  64.         }
  66.         $e->setStatusText($statusText);
  67.         $e->setStatusCode($statusCode);
  68.         $e->setHeaders($headers);
  69.         $e->setTraceFromThrowable($exception);
  70.         $e->setClass(get_debug_type($exception));
  71.         $e->setFile($exception->getFile());
  72.         $e->setLine($exception->getLine());
  74.         $previous = $exception->getPrevious();
  76.         if ($previous instanceof \Throwable) {
  77.             $e->setPrevious(static::createFromThrowable($previous));
  78.         }
  80.         return $e;
  81.     }
  83.     public function toArray(): array
  84.     {
  85.         $exceptions = [];
  86.         foreach (array_merge([$this], $this->getAllPrevious()) as $exception) {
  87.             $exceptions[] = [
  88.                 'message' => $exception->getMessage(),
  89.                 'class' => $exception->getClass(),
  90.                 'trace' => $exception->getTrace(),
  91.             ];
  92.         }
  94.         return $exceptions;
  95.     }
  97.     public function getStatusCode(): int
  98.     {
  99.         return $this->statusCode;
  100.     }
  102.     /**
  103.      * @return $this
  104.      */
  105.     public function setStatusCode(int $code): static
  106.     {
  107.         $this->statusCode = $code;
  109.         return $this;
  110.     }
  112.     public function getHeaders(): array
  113.     {
  114.         return $this->headers;
  115.     }
  117.     /**
  118.      * @return $this
  119.      */
  120.     public function setHeaders(array $headers): static
  121.     {
  122.         $this->headers = $headers;
  124.         return $this;
  125.     }
  127.     public function getClass(): string
  128.     {
  129.         return $this->class;
  130.     }
  132.     /**
  133.      * @return $this
  134.      */
  135.     public function setClass(string $class): static
  136.     {
  137.         $this->class = str_contains($class, "@anonymous\0") ? (get_parent_class($class) ?: key(class_implements($class)) ?: 'class').'@anonymous' : $class;
  139.         return $this;
  140.     }
  142.     public function getFile(): string
  143.     {
  144.         return $this->file;
  145.     }
  147.     /**
  148.      * @return $this
  149.      */
  150.     public function setFile(string $file): static
  151.     {
  152.         $this->file = $file;
  154.         return $this;
  155.     }
  157.     public function getLine(): int
  158.     {
  159.         return $this->line;
  160.     }
  162.     /**
  163.      * @return $this
  164.      */
  165.     public function setLine(int $line): static
  166.     {
  167.         $this->line = $line;
  169.         return $this;
  170.     }
  172.     public function getStatusText(): string
  173.     {
  174.         return $this->statusText;
  175.     }
  177.     /**
  178.      * @return $this
  179.      */
  180.     public function setStatusText(string $statusText): static
  181.     {
  182.         $this->statusText = $statusText;
  184.         return $this;
  185.     }
  187.     public function getMessage(): string
  188.     {
  189.         return $this->message;
  190.     }
  192.     /**
  193.      * @return $this
  194.      */
  195.     public function setMessage(string $message): static
  196.     {
  197.         if (str_contains($message, "@anonymous\0")) {
  198.             $message = preg_replace_callback('/[a-zA-Z_\x7f-\xff][\\\\a-zA-Z0-9_\x7f-\xff]*+@anonymous\x00.*?\.php(?:0x?|:[0-9]++\$)[0-9a-fA-F]++/', function ($m) {
  199.                 return class_exists($m[0], false) ? (get_parent_class($m[0]) ?: key(class_implements($m[0])) ?: 'class').'@anonymous' : $m[0];
  200.             }, $message);
  201.         }
  203.         $this->message = $message;
  205.         return $this;
  206.     }
  208.     /**
  209.      * @return int|string int most of the time (might be a string with PDOException)
  210.      */
  211.     public function getCode(): int|string
  212.     {
  213.         return $this->code;
  214.     }
  216.     /**
  217.      * @return $this
  218.      */
  219.     public function setCode(int|string $code): static
  220.     {
  221.         $this->code = $code;
  223.         return $this;
  224.     }
  226.     public function getPrevious(): ?self
  227.     {
  228.         return $this->previous;
  229.     }
  231.     /**
  232.      * @return $this
  233.      */
  234.     public function setPrevious(?self $previous): static
  235.     {
  236.         $this->previous = $previous;
  238.         return $this;
  239.     }
  241.     /**
  242.      * @return self[]
  243.      */
  244.     public function getAllPrevious(): array
  245.     {
  246.         $exceptions = [];
  247.         $e = $this;
  248.         while ($e = $e->getPrevious()) {
  249.             $exceptions[] = $e;
  250.         }
  252.         return $exceptions;
  253.     }
  255.     public function getTrace(): array
  256.     {
  257.         return $this->trace;
  258.     }
  260.     /**
  261.      * @return $this
  262.      */
  263.     public function setTraceFromThrowable(\Throwable $throwable): static
  264.     {
  265.         $this->traceAsString = $throwable->getTraceAsString();
  267.         return $this->setTrace($throwable->getTrace(), $throwable->getFile(), $throwable->getLine());
  268.     }
  270.     /**
  271.      * @return $this
  272.      */
  273.     public function setTrace(array $trace, ?string $file, ?int $line): static
  274.     {
  275.         $this->trace = [];
  276.         $this->trace[] = [
  277.             'namespace' => '',
  278.             'short_class' => '',
  279.             'class' => '',
  280.             'type' => '',
  281.             'function' => '',
  282.             'file' => $file,
  283.             'line' => $line,
  284.             'args' => [],
  285.         ];
  286.         foreach ($trace as $entry) {
  287.             $class = '';
  288.             $namespace = '';
  289.             if (isset($entry['class'])) {
  290.                 $parts = explode('\\', $entry['class']);
  291.                 $class = array_pop($parts);
  292.                 $namespace = implode('\\', $parts);
  293.             }
  295.             $this->trace[] = [
  296.                 'namespace' => $namespace,
  297.                 'short_class' => $class,
  298.                 'class' => $entry['class'] ?? '',
  299.                 'type' => $entry['type'] ?? '',
  300.                 'function' => $entry['function'] ?? null,
  301.                 'file' => $entry['file'] ?? null,
  302.                 'line' => $entry['line'] ?? null,
  303.                 'args' => isset($entry['args']) ? $this->flattenArgs($entry['args']) : [],
  304.             ];
  305.         }
  307.         return $this;
  308.     }
  310.     private function flattenArgs(array $args, int $level = 0, int &$count = 0): array
  311.     {
  312.         $result = [];
  313.         foreach ($args as $key => $value) {
  314.             if (++$count > 1e4) {
  315.                 return ['array', '*SKIPPED over 10000 entries*'];
  316.             }
  317.             if ($value instanceof \__PHP_Incomplete_Class) {
  318.                 $result[$key] = ['incomplete-object', $this->getClassNameFromIncomplete($value)];
  319.             } elseif (\is_object($value)) {
  320.                 $result[$key] = ['object', get_debug_type($value)];
  321.             } elseif (\is_array($value)) {
  322.                 if ($level > 10) {
  323.                     $result[$key] = ['array', '*DEEP NESTED ARRAY*'];
  324.                 } else {
  325.                     $result[$key] = ['array', $this->flattenArgs($value, $level + 1, $count)];
  326.                 }
  327.             } elseif (null === $value) {
  328.                 $result[$key] = ['null', null];
  329.             } elseif (\is_bool($value)) {
  330.                 $result[$key] = ['boolean', $value];
  331.             } elseif (\is_int($value)) {
  332.                 $result[$key] = ['integer', $value];
  333.             } elseif (\is_float($value)) {
  334.                 $result[$key] = ['float', $value];
  335.             } elseif (\is_resource($value)) {
  336.                 $result[$key] = ['resource', get_resource_type($value)];
  337.             } else {
  338.                 $result[$key] = ['string', (string) $value];
  339.             }
  340.         }
  342.         return $result;
  343.     }
  345.     private function getClassNameFromIncomplete(\__PHP_Incomplete_Class $value): string
  346.     {
  347.         $array = new \ArrayObject($value);
  349.         return $array['__PHP_Incomplete_Class_Name'];
  350.     }
  352.     public function getTraceAsString(): string
  353.     {
  354.         return $this->traceAsString;
  355.     }
  357.     /**
  358.      * @return $this
  359.      */
  360.     public function setAsString(?string $asString): static
  361.     {
  362.         $this->asString = $asString;
  364.         return $this;
  365.     }
  367.     public function getAsString(): string
  368.     {
  369.         if (null !== $this->asString) {
  370.             return $this->asString;
  371.         }
  373.         $message = '';
  374.         $next = false;
  376.         foreach (array_reverse(array_merge([$this], $this->getAllPrevious())) as $exception) {
  377.             if ($next) {
  378.                 $message .= 'Next ';
  379.             } else {
  380.                 $next = true;
  381.             }
  382.             $message .= $exception->getClass();
  384.             if ('' != $exception->getMessage()) {
  385.                 $message .= ': '.$exception->getMessage();
  386.             }
  388.             $message .= ' in '.$exception->getFile().':'.$exception->getLine().
  389.                 "\nStack trace:\n".$exception->getTraceAsString()."\n\n";
  390.         }
  392.         return rtrim($message);
  393.     }
  394. }