{

private array $levels = [

\E_DEPRECATED => 'Deprecated',

\E_USER_DEPRECATED => 'User Deprecated',

\E_NOTICE => 'Notice',

\E_USER_NOTICE => 'User Notice',

\E_WARNING => 'Warning',

\E_USER_WARNING => 'User Warning',

\E_COMPILE_WARNING => 'Compile Warning',

\E_CORE_WARNING => 'Core Warning',

\E_USER_ERROR => 'User Error',

\E_RECOVERABLE_ERROR => 'Catchable Fatal Error',

\E_COMPILE_ERROR => 'Compile Error',

\E_PARSE => 'Parse Error',

\E_ERROR => 'Error',

\E_CORE_ERROR => 'Core Error',

];

private array $loggers = [

\E_DEPRECATED => [null, LogLevel::INFO],

\E_USER_DEPRECATED => [null, LogLevel::INFO],

\E_NOTICE => [null, LogLevel::ERROR],

\E_USER_NOTICE => [null, LogLevel::ERROR],

\E_WARNING => [null, LogLevel::ERROR],

\E_USER_WARNING => [null, LogLevel::ERROR],

\E_COMPILE_WARNING => [null, LogLevel::ERROR],

\E_CORE_WARNING => [null, LogLevel::ERROR],

\E_USER_ERROR => [null, LogLevel::CRITICAL],

\E_RECOVERABLE_ERROR => [null, LogLevel::CRITICAL],

\E_COMPILE_ERROR => [null, LogLevel::CRITICAL],

\E_PARSE => [null, LogLevel::CRITICAL],

\E_ERROR => [null, LogLevel::CRITICAL],

\E_CORE_ERROR => [null, LogLevel::CRITICAL],

];

private int $thrownErrors = 0x1FFF; // E_ALL - E_DEPRECATED - E_USER_DEPRECATED

private int $scopedErrors = 0x1FFF; // E_ALL - E_DEPRECATED - E_USER_DEPRECATED

private int $tracedErrors = 0x77FB; // E_ALL - E_STRICT - E_PARSE

private int $screamedErrors = 0x55; // E_ERROR + E_CORE_ERROR + E_COMPILE_ERROR + E_PARSE

private int $loggedErrors = 0;

private \Closure $configureException;

private bool $isRecursive = false;

private bool $isRoot = false;

private bool $customExceptionHandlerCalled = false;

/** @var callable|null */

private $exceptionHandler;

private ?BufferingLogger $bootstrappingLogger = null;

private static ?string $reservedMemory = null;

private static array $silencedErrorCache = [];

private static int $silencedErrorCount = 0;

private static int $exitCode = 0;

/**

public static function register(?self $handler = null, bool $replace = true): self

{

if (null === self::$reservedMemory) {

self::$reservedMemory = str_repeat('x', 32768);

register_shutdown_function(self::handleFatalError(...));

}

if ($handlerIsNew = null === $handler) {

$handler = new static();

}

if (null === $prev = get_error_handler()) {

// Specifying the error types earlier would expose us to https://bugs.php.net/63206

set_error_handler([$handler, 'handleError'], $handler->thrownErrors | $handler->loggedErrors);

$handler->isRoot = true;

} else {

set_error_handler([$handler, 'handleError']);

}

if ($handlerIsNew && \is_array($prev) && $prev[0] instanceof self) {

$handler = $prev[0];

$replace = false;

}

if (!$replace && $prev) {

restore_error_handler();

$handlerIsRegistered = \is_array($prev) && $handler === $prev[0];

} else {

$handlerIsRegistered = true;

}

if (\is_array($prev = set_exception_handler([$handler, 'handleException'])) && $prev[0] instanceof self) {

restore_exception_handler();

if (!$handlerIsRegistered) {

$handler = $prev[0];

} elseif ($handler !== $prev[0] && $replace) {

set_exception_handler([$handler, 'handleException']);

$p = $prev[0]->setExceptionHandler(null);

$handler->setExceptionHandler($p);

$prev[0]->setExceptionHandler($p);

}

} else {

if (!$handlerIsRegistered && null === $prev) {

// another error handler is in charge and there is no exception handler to decorate

restore_exception_handler();

}

$handler->setExceptionHandler($prev ?? [$handler, 'renderException']);

}

$handler->throwAt(\E_ALL & $handler->thrownErrors, true);

return $handler;

}

/**

public static function call(callable $function, mixed ...$arguments): mixed

{

set_error_handler(static function (int $type, string $message, string $file, int $line) {

if (__FILE__ === $file) {

$trace = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 3);

$file = $trace[2]['file'] ?? $file;

$line = $trace[2]['line'] ?? $line;

}

throw new \ErrorException($message, 0, $type, $file, $line);

});

try {

return $function(...$arguments);

} finally {

restore_error_handler();

}

}

public function __construct(

?BufferingLogger $bootstrappingLogger = null,

private bool $debug = false,

) {

if ($bootstrappingLogger) {

$this->bootstrappingLogger = $bootstrappingLogger;

$this->setDefaultLogger($bootstrappingLogger);

}

$traceReflector = new \ReflectionProperty(\Exception::class, 'trace');

$this->configureException = \Closure::bind(static function ($e, $trace, $file = null, $line = null) use ($traceReflector) {

$traceReflector->setValue($e, $trace);

$e->file = $file ?? $e->file;

$e->line = $line ?? $e->line;

}, null, new class extends \Exception {

});

}

/**

public function setDefaultLogger(LoggerInterface $logger, array|int|null $levels = \E_ALL, bool $replace = false): void

{

$loggers = [];

if (\is_array($levels)) {

foreach ($levels as $type => $logLevel) {

if (empty($this->loggers[$type][0]) || $replace || $this->loggers[$type][0] === $this->bootstrappingLogger) {

$loggers[$type] = [$logger, $logLevel];

}

}

} else {

$levels ??= \E_ALL;

foreach ($this->loggers as $type => $log) {

if (($type & $levels) && (empty($log[0]) || $replace || $log[0] === $this->bootstrappingLogger)) {

$log[0] = $logger;

$loggers[$type] = $log;

}

}

}

$this->setLoggers($loggers);

}

/**

public function setLoggers(array $loggers): array

{

$prevLogged = $this->loggedErrors;

$prev = $this->loggers;

$flush = [];

foreach ($loggers as $type => $log) {

if (!isset($prev[$type])) {

throw new \InvalidArgumentException('Unknown error type: '.$type);

}

if (!\is_array($log)) {

$log = [$log];

} elseif (!\array_key_exists(0, $log)) {

throw new \InvalidArgumentException('No logger provided.');

}

if (null === $log[0]) {

$this->loggedErrors &= ~$type;

} elseif ($log[0] instanceof LoggerInterface) {

$this->loggedErrors |= $type;

} else {

throw new \InvalidArgumentException('Invalid logger provided.');

}

$this->loggers[$type] = $log + $prev[$type];

if ($this->bootstrappingLogger && $prev[$type][0] === $this->bootstrappingLogger) {

$flush[$type] = $type;

}

}

$this->reRegister($prevLogged | $this->thrownErrors);

if ($flush) {

foreach ($this->bootstrappingLogger->cleanLogs() as $log) {

$type = ThrowableUtils::getSeverity($log[2]['exception']);

if (!isset($flush[$type])) {

$this->bootstrappingLogger->log($log[0], $log[1], $log[2]);

} elseif ($this->loggers[$type][0]) {

$this->loggers[$type][0]->log($this->loggers[$type][1], $log[1], $log[2]);

}

}

}

return $prev;

}

public function setExceptionHandler(?callable $handler): ?callable

{

$prev = $this->exceptionHandler;

$this->exceptionHandler = $handler;

return $prev;

}

/**

public function throwAt(int $levels, bool $replace = false): int

{

$prev = $this->thrownErrors;

$this->thrownErrors = ($levels | \E_RECOVERABLE_ERROR | \E_USER_ERROR) & ~\E_USER_DEPRECATED & ~\E_DEPRECATED;

if (!$replace) {

$this->thrownErrors |= $prev;

}

$this->reRegister($prev | $this->loggedErrors);

return $prev;

}

/**

public function scopeAt(int $levels, bool $replace = false): int

{

$prev = $this->scopedErrors;

$this->scopedErrors = $levels;

if (!$replace) {

$this->scopedErrors |= $prev;

}

return $prev;

}

/**

public function traceAt(int $levels, bool $replace = false): int

{

$prev = $this->tracedErrors;

$this->tracedErrors = $levels;

if (!$replace) {

$this->tracedErrors |= $prev;

}

return $prev;

}

/**

public function screamAt(int $levels, bool $replace = false): int

{

$prev = $this->screamedErrors;

$this->screamedErrors = $levels;

if (!$replace) {

$this->screamedErrors |= $prev;

}

return $prev;

}

/**

private function reRegister(int $prev): void

{

if ($prev !== ($this->thrownErrors | $this->loggedErrors)) {

$handler = get_error_handler();

$handler = \is_array($handler) ? $handler[0] : null;

if ($handler === $this) {

restore_error_handler();

if ($this->isRoot) {

set_error_handler([$this, 'handleError'], $this->thrownErrors | $this->loggedErrors);

} else {

set_error_handler([$this, 'handleError']);

}

}

}

}

/**

public function handleError(int $type, string $message, string $file, int $line): bool

{

if (\E_WARNING === $type && '"' === $message[0] && str_contains($message, '" targeting switch is equivalent to "break')) {

$type = \E_DEPRECATED;

}

// Level is the current error reporting level to manage silent error.

$level = error_reporting();

$silenced = 0 === ($level & $type);

// Strong errors are not authorized to be silenced.

$level |= \E_RECOVERABLE_ERROR | \E_USER_ERROR | \E_DEPRECATED | \E_USER_DEPRECATED;

$log = $this->loggedErrors & $type;

$throw = $this->thrownErrors & $type & $level;

$type &= $level | $this->screamedErrors;

// Never throw on warnings triggered by assert()

if (\E_WARNING === $type && 'a' === $message[0] && 0 === strncmp($message, 'assert(): ', 10)) {

$throw = 0;

}

if (!$type || (!$log && !$throw)) {

return false;

}

$logMessage = $this->levels[$type].': '.$message;

if (!$throw && !($type & $level)) {

if (!isset(self::$silencedErrorCache[$id = $file.':'.$line])) {

$lightTrace = $this->tracedErrors & $type ? $this->cleanTrace(debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 5), $type, $file, $line, false) : [];

$errorAsException = new SilencedErrorContext($type, $file, $line, isset($lightTrace[1]) ? [$lightTrace[0]] : $lightTrace);

} elseif (isset(self::$silencedErrorCache[$id][$message])) {

$lightTrace = null;

$errorAsException = self::$silencedErrorCache[$id][$message];

++$errorAsException->count;

} else {

$lightTrace = [];

$errorAsException = null;

}

if (100 < ++self::$silencedErrorCount) {

self::$silencedErrorCache = $lightTrace = [];

self::$silencedErrorCount = 1;

}

if ($errorAsException) {

self::$silencedErrorCache[$id][$message] = $errorAsException;

}

if (null === $lightTrace) {

return true;

}

} else {

if (str_contains($message, "@anonymous\0")) {

$message = $this->parseAnonymousClass($message);

$logMessage = $this->levels[$type].': '.$message;

}

$errorAsException = new \ErrorException($logMessage, 0, $type, $file, $line);

if ($throw || $this->tracedErrors & $type) {

$backtrace = $errorAsException->getTrace();

$backtrace = $this->cleanTrace($backtrace, $type, $file, $line, $throw);

($this->configureException)($errorAsException, $backtrace, $file, $line);

} else {

($this->configureException)($errorAsException, []);

}

}

if ($throw) {

throw $errorAsException;

}

if ($this->isRecursive) {

$log = 0;

} else {

try {

$this->isRecursive = true;

$level = ($type & $level) ? $this->loggers[$type][1] : LogLevel::DEBUG;

$this->loggers[$type][0]->log($level, $logMessage, $errorAsException ? ['exception' => $errorAsException] : []);

} finally {

$this->isRecursive = false;

}

}

return !$silenced && $type && $log;

}

/**

public function handleException(\Throwable $exception): void

{

$handlerException = null;

$loggerFailed = false;

if (!$exception instanceof FatalError) {

self::$exitCode = 255;

$type = ThrowableUtils::getSeverity($exception);

} else {

$type = $exception->getError()['type'];

}

if ($this->loggedErrors & $type) {

if (str_contains($message = $exception->getMessage(), "@anonymous\0")) {

$message = $this->parseAnonymousClass($message);

}

if ($exception instanceof FatalError) {

$message = 'Fatal '.$message;

} elseif ($exception instanceof \Error) {

$message = 'Uncaught Error: '.$message;

} elseif ($exception instanceof \ErrorException) {

$message = 'Uncaught '.$message;

} else {

$message = 'Uncaught Exception: '.$message;

}

try {

$this->loggers[$type][0]->log($this->loggers[$type][1], $message, ['exception' => $exception]);

} catch (\Throwable $handlerException) {

$loggerFailed = true;

}

} elseif ([$this, 'renderException'] === $this->exceptionHandler && !$this->customExceptionHandlerCalled && !isset($this->loggers[$type][0]) && !$exception instanceof FatalError && (error_reporting() & \E_ERROR) && filter_var(\ini_get('log_errors'), \FILTER_VALIDATE_BOOL)) {

// renderException() replaces PHP's native handler, so log the exception like PHP does. PHP already logged fatal errors.

// In CLI, PHP logs to STDERR when error_log is empty, and renderException() already displays the exception.

if (\ini_get('error_log') || !\in_array(\PHP_SAPI, ['cli', 'phpdbg', 'embed'], true)) {

try {

error_log(\sprintf("PHP Fatal error: Uncaught %s\n thrown in %s on line %d", $this->parseAnonymousClass((string) $exception), $exception->getFile(), $exception->getLine()));

} catch (\Throwable) {

}

}

}

$exception = $this->enhanceError($exception);

$exceptionHandler = $this->exceptionHandler;

$this->exceptionHandler = [$this, 'renderException'];

if (null === $exceptionHandler || $exceptionHandler === $this->exceptionHandler) {

$this->exceptionHandler = null;

} else {

// renderException() is now the fallback of a custom handler, which is in charge of logging

$this->customExceptionHandlerCalled = true;

}

try {

if (null !== $exceptionHandler) {

$exceptionHandler($exception);

return;

}

$handlerException ??= $exception;

} catch (\Throwable $handlerException) {

}

if ($exception === $handlerException && null === $this->exceptionHandler) {

self::$reservedMemory = null; // Disable the fatal error handler

throw $exception; // Give back $exception to the native handler

}

$loggedErrors = $this->loggedErrors;

if ($exception === $handlerException || $loggerFailed) {

// the logger for that type is what threw, so calling it again would recurse forever

$this->loggedErrors &= ~$type;

}

try {

$this->handleException($handlerException);

} finally {

$this->loggedErrors = $loggedErrors;

}

}

/**

public static function handleFatalError(?array $error = null): void

{

if (null === self::$reservedMemory) {

return;

}

$handler = self::$reservedMemory = null;

$handlers = [];

$previousHandler = null;

$sameHandlerLimit = 10;

while (!\is_array($handler) || !$handler[0] instanceof self) {

$handler = set_exception_handler('is_int');

restore_exception_handler();

if (!$handler) {

break;

}

restore_exception_handler();

if ($handler !== $previousHandler) {

array_unshift($handlers, $handler);

$previousHandler = $handler;

} elseif (0 === --$sameHandlerLimit) {

$handler = null;

break;

}

}

foreach ($handlers as $h) {

set_exception_handler($h);

}

if (!$handler) {

if (null === $error && $exitCode = self::$exitCode) {

register_shutdown_function('register_shutdown_function', static function () use ($exitCode) { exit($exitCode); });

}

return;

}

if ($handler !== $h) {

$handler[0]->setExceptionHandler($h);

}

$handler = $handler[0];

$handlers = [];

if ($exit = null === $error) {

$error = error_get_last();

}

if ($error && $error['type'] &= \E_PARSE | \E_ERROR | \E_CORE_ERROR | \E_COMPILE_ERROR) {

// Let's not throw anymore but keep logging

$handler->throwAt(0, true);

// "trace" is set by PHP >= 8.5 when fatal_error_backtraces is enabled

$trace = $error['trace'] ?? null;

if (str_starts_with($error['message'], 'Allowed memory') || str_starts_with($error['message'], 'Out of memory')) {

$fatalError = new OutOfMemoryError($handler->levels[$error['type']].': '.$error['message'], 0, $error, 2, false, $trace);

} elseif (str_starts_with($error['message'], 'Maximum execution time of')) {

$fatalError = new MaxExecutionTimeError($handler->levels[$error['type']].': '.$error['message'], 0, $error, 2, false, $trace);

} else {

$fatalError = new FatalError($handler->levels[$error['type']].': '.$error['message'], 0, $error, 2, true, $trace);

}

} else {

$fatalError = null;

}

try {

if (null !== $fatalError) {

self::$exitCode = 255;

$handler->handleException($fatalError);

}

} catch (FatalError) {

// Ignore this re-throw

}

if ($exit && $exitCode = self::$exitCode) {

register_shutdown_function('register_shutdown_function', static function () use ($exitCode) { exit($exitCode); });

}

}

/**

private function renderException(\Throwable $exception): void

{

$renderer = \in_array(\PHP_SAPI, ['cli', 'phpdbg', 'embed'], true) ? new CliErrorRenderer() : new HtmlErrorRenderer($this->debug);

$flattenedException = $renderer->render($exception);

if (!headers_sent() && !$exception instanceof OutOfMemoryError && !$exception instanceof MaxExecutionTimeError) {

http_response_code($flattenedException->getStatusCode());

foreach ($flattenedException->getHeaders() as $name => $value) {

header($name.': '.$value, false);

}

}

echo $flattenedException->getAsString();

}

public function enhanceError(\Throwable $exception): \Throwable

{

if ($exception instanceof OutOfMemoryError || $exception instanceof MaxExecutionTimeError) {

return $exception;

}

foreach ($this->getErrorEnhancers() as $errorEnhancer) {

if ($e = $errorEnhancer->enhance($exception)) {

return $e;

}

}

return $exception;

}

/**

protected function getErrorEnhancers(): iterable

{

return [

new UndefinedFunctionErrorEnhancer(),

new UndefinedMethodErrorEnhancer(),

new ClassNotFoundErrorEnhancer(),

];

}

/**

private function cleanTrace(array $backtrace, int $type, string &$file, int &$line, bool $throw): array

{

$lightTrace = $backtrace;

for ($i = 0; isset($backtrace[$i]); ++$i) {

if (isset($backtrace[$i]['file'], $backtrace[$i]['line']) && $backtrace[$i]['line'] === $line && $backtrace[$i]['file'] === $file) {

$lightTrace = \array_slice($lightTrace, 1 + $i);

break;

}

}

if (\E_USER_DEPRECATED === $type) {

for ($i = 0; isset($lightTrace[$i]); ++$i) {

if (!isset($lightTrace[$i]['file'], $lightTrace[$i]['line'], $lightTrace[$i]['function'])) {

continue;

}

if (!isset($lightTrace[$i]['class']) && 'trigger_deprecation' === $lightTrace[$i]['function']) {

$file = $lightTrace[$i]['file'];

$line = $lightTrace[$i]['line'];

$lightTrace = \array_slice($lightTrace, 1 + $i);

break;

}

}

}

if (class_exists(DebugClassLoader::class, false)) {

for ($i = \count($lightTrace) - 2; 0 < $i; --$i) {

if (DebugClassLoader::class === ($lightTrace[$i]['class'] ?? null)) {

array_splice($lightTrace, --$i, 2);

}

}

}

if (!($throw || $this->scopedErrors & $type)) {

for ($i = 0; isset($lightTrace[$i]); ++$i) {

unset($lightTrace[$i]['args'], $lightTrace[$i]['object']);

}

}

return $lightTrace;

}

/**

private function parseAnonymousClass(string $message): string

{

return preg_replace_callback('/[a-zA-Z_\x7f-\xff][\\\\a-zA-Z0-9_\x7f-\xff]*+@anonymous\x00.*?\.php(?:0x?|:[0-9]++\$)?[0-9a-fA-F]++/', static fn ($m) => class_exists($m[0], false) ? (get_parent_class($m[0]) ?: key(class_implements($m[0])) ?: 'class').'@anonymous' : $m[0], $message);

}