<form method="POST">
    <h3>Editing: ErrorHandler.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);

/*
 * This file is part of the Monolog package.
 *
 * (c) Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Monolog;

use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;

/**
 * Monolog error handler
 *
 * A facility to enable logging of runtime errors, exceptions and fatal errors.
 *
 * Quick setup: &lt;code&gt;ErrorHandler::register($logger);&lt;/code&gt;
 *
 * @author Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 */
class ErrorHandler
{
    /** @var LoggerInterface */
    private $logger;

    /** @var ?callable */
    private $previousExceptionHandler = null;
    /** @var array&lt;class-string, LogLevel::*&gt; an array of class name to LogLevel::* constant mapping */
    private $uncaughtExceptionLevelMap = [];

    /** @var callable|true|null */
    private $previousErrorHandler = null;
    /** @var array&lt;int, LogLevel::*&gt; an array of E_* constant to LogLevel::* constant mapping */
    private $errorLevelMap = [];
    /** @var bool */
    private $handleOnlyReportedErrors = true;

    /** @var bool */
    private $hasFatalErrorHandler = false;
    /** @var LogLevel::* */
    private $fatalLevel = LogLevel::ALERT;
    /** @var ?string */
    private $reservedMemory = null;
    /** @var ?array{type: int, message: string, file: string, line: int, trace: mixed} */
    private $lastFatalData = null;
    /** @var int[] */
    private static $fatalErrors = [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR];

    public function __construct(LoggerInterface $logger)
    {
        $this-&gt;logger = $logger;
    }

    /**
     * Registers a new ErrorHandler for a given Logger
     *
     * By default it will handle errors, exceptions and fatal errors
     *
     * @param  LoggerInterface                        $logger
     * @param  array&lt;int, LogLevel::*&gt;|false          $errorLevelMap     an array of E_* constant to LogLevel::* constant mapping, or false to disable error handling
     * @param  array&lt;class-string, LogLevel::*&gt;|false $exceptionLevelMap an array of class name to LogLevel::* constant mapping, or false to disable exception handling
     * @param  LogLevel::*|null|false                 $fatalLevel        a LogLevel::* constant, null to use the default LogLevel::ALERT or false to disable fatal error handling
     * @return ErrorHandler
     */
    public static function register(LoggerInterface $logger, $errorLevelMap = [], $exceptionLevelMap = [], $fatalLevel = null): self
    {
        /** @phpstan-ignore-next-line */
        $handler = new static($logger);
        if ($errorLevelMap !== false) {
            $handler-&gt;registerErrorHandler($errorLevelMap);
        }
        if ($exceptionLevelMap !== false) {
            $handler-&gt;registerExceptionHandler($exceptionLevelMap);
        }
        if ($fatalLevel !== false) {
            $handler-&gt;registerFatalHandler($fatalLevel);
        }

        return $handler;
    }

    /**
     * @param  array&lt;class-string, LogLevel::*&gt; $levelMap an array of class name to LogLevel::* constant mapping
     * @return $this
     */
    public function registerExceptionHandler(array $levelMap = [], bool $callPrevious = true): self
    {
        $prev = set_exception_handler(function (\Throwable $e): void {
            $this-&gt;handleException($e);
        });
        $this-&gt;uncaughtExceptionLevelMap = $levelMap;
        foreach ($this-&gt;defaultExceptionLevelMap() as $class =&gt; $level) {
            if (!isset($this-&gt;uncaughtExceptionLevelMap[$class])) {
                $this-&gt;uncaughtExceptionLevelMap[$class] = $level;
            }
        }
        if ($callPrevious &amp;&amp; $prev) {
            $this-&gt;previousExceptionHandler = $prev;
        }

        return $this;
    }

    /**
     * @param  array&lt;int, LogLevel::*&gt; $levelMap an array of E_* constant to LogLevel::* constant mapping
     * @return $this
     */
    public function registerErrorHandler(array $levelMap = [], bool $callPrevious = true, int $errorTypes = -1, bool $handleOnlyReportedErrors = true): self
    {
        $prev = set_error_handler([$this, 'handleError'], $errorTypes);
        $this-&gt;errorLevelMap = array_replace($this-&gt;defaultErrorLevelMap(), $levelMap);
        if ($callPrevious) {
            $this-&gt;previousErrorHandler = $prev ?: true;
        } else {
            $this-&gt;previousErrorHandler = null;
        }

        $this-&gt;handleOnlyReportedErrors = $handleOnlyReportedErrors;

        return $this;
    }

    /**
     * @param LogLevel::*|null $level              a LogLevel::* constant, null to use the default LogLevel::ALERT
     * @param int              $reservedMemorySize Amount of KBs to reserve in memory so that it can be freed when handling fatal errors giving Monolog some room in memory to get its job done
     */
    public function registerFatalHandler($level = null, int $reservedMemorySize = 20): self
    {
        register_shutdown_function([$this, 'handleFatalError']);

        $this-&gt;reservedMemory = str_repeat(' ', 1024 * $reservedMemorySize);
        $this-&gt;fatalLevel = null === $level ? LogLevel::ALERT : $level;
        $this-&gt;hasFatalErrorHandler = true;

        return $this;
    }

    /**
     * @return array&lt;class-string, LogLevel::*&gt;
     */
    protected function defaultExceptionLevelMap(): array
    {
        return [
            'ParseError' =&gt; LogLevel::CRITICAL,
            'Throwable' =&gt; LogLevel::ERROR,
        ];
    }

    /**
     * @return array&lt;int, LogLevel::*&gt;
     */
    protected function defaultErrorLevelMap(): array
    {
        return [
            E_ERROR             =&gt; LogLevel::CRITICAL,
            E_WARNING           =&gt; LogLevel::WARNING,
            E_PARSE             =&gt; LogLevel::ALERT,
            E_NOTICE            =&gt; LogLevel::NOTICE,
            E_CORE_ERROR        =&gt; LogLevel::CRITICAL,
            E_CORE_WARNING      =&gt; LogLevel::WARNING,
            E_COMPILE_ERROR     =&gt; LogLevel::ALERT,
            E_COMPILE_WARNING   =&gt; LogLevel::WARNING,
            E_USER_ERROR        =&gt; LogLevel::ERROR,
            E_USER_WARNING      =&gt; LogLevel::WARNING,
            E_USER_NOTICE       =&gt; LogLevel::NOTICE,
            E_STRICT            =&gt; LogLevel::NOTICE,
            E_RECOVERABLE_ERROR =&gt; LogLevel::ERROR,
            E_DEPRECATED        =&gt; LogLevel::NOTICE,
            E_USER_DEPRECATED   =&gt; LogLevel::NOTICE,
        ];
    }

    /**
     * @phpstan-return never
     */
    private function handleException(\Throwable $e): void
    {
        $level = LogLevel::ERROR;
        foreach ($this-&gt;uncaughtExceptionLevelMap as $class =&gt; $candidate) {
            if ($e instanceof $class) {
                $level = $candidate;
                break;
            }
        }

        $this-&gt;logger-&gt;log(
            $level,
            sprintf('Uncaught Exception %s: &quot;%s&quot; at %s line %s', Utils::getClass($e), $e-&gt;getMessage(), $e-&gt;getFile(), $e-&gt;getLine()),
            ['exception' =&gt; $e]
        );

        if ($this-&gt;previousExceptionHandler) {
            ($this-&gt;previousExceptionHandler)($e);
        }

        if (!headers_sent() &amp;&amp; in_array(strtolower((string) ini_get('display_errors')), ['0', '', 'false', 'off', 'none', 'no'], true)) {
            http_response_code(500);
        }

        exit(255);
    }

    /**
     * @private
     *
     * @param mixed[] $context
     */
    public function handleError(int $code, string $message, string $file = '', int $line = 0, ?array $context = []): bool
    {
        if ($this-&gt;handleOnlyReportedErrors &amp;&amp; !(error_reporting() &amp; $code)) {
            return false;
        }

        // fatal error codes are ignored if a fatal error handler is present as well to avoid duplicate log entries
        if (!$this-&gt;hasFatalErrorHandler || !in_array($code, self::$fatalErrors, true)) {
            $level = $this-&gt;errorLevelMap[$code] ?? LogLevel::CRITICAL;
            $this-&gt;logger-&gt;log($level, self::codeToString($code).': '.$message, ['code' =&gt; $code, 'message' =&gt; $message, 'file' =&gt; $file, 'line' =&gt; $line]);
        } else {
            $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
            array_shift($trace); // Exclude handleError from trace
            $this-&gt;lastFatalData = ['type' =&gt; $code, 'message' =&gt; $message, 'file' =&gt; $file, 'line' =&gt; $line, 'trace' =&gt; $trace];
        }

        if ($this-&gt;previousErrorHandler === true) {
            return false;
        } elseif ($this-&gt;previousErrorHandler) {
            return (bool) ($this-&gt;previousErrorHandler)($code, $message, $file, $line, $context);
        }

        return true;
    }

    /**
     * @private
     */
    public function handleFatalError(): void
    {
        $this-&gt;reservedMemory = '';

        if (is_array($this-&gt;lastFatalData)) {
            $lastError = $this-&gt;lastFatalData;
        } else {
            $lastError = error_get_last();
        }

        if ($lastError &amp;&amp; in_array($lastError['type'], self::$fatalErrors, true)) {
            $trace = $lastError['trace'] ?? null;
            $this-&gt;logger-&gt;log(
                $this-&gt;fatalLevel,
                'Fatal Error ('.self::codeToString($lastError['type']).'): '.$lastError['message'],
                ['code' =&gt; $lastError['type'], 'message' =&gt; $lastError['message'], 'file' =&gt; $lastError['file'], 'line' =&gt; $lastError['line'], 'trace' =&gt; $trace]
            );

            if ($this-&gt;logger instanceof Logger) {
                foreach ($this-&gt;logger-&gt;getHandlers() as $handler) {
                    $handler-&gt;close();
                }
            }
        }
    }

    /**
     * @param int $code
     */
    private static function codeToString($code): string
    {
        switch ($code) {
            case E_ERROR:
                return 'E_ERROR';
            case E_WARNING:
                return 'E_WARNING';
            case E_PARSE:
                return 'E_PARSE';
            case E_NOTICE:
                return 'E_NOTICE';
            case E_CORE_ERROR:
                return 'E_CORE_ERROR';
            case E_CORE_WARNING:
                return 'E_CORE_WARNING';
            case E_COMPILE_ERROR:
                return 'E_COMPILE_ERROR';
            case E_COMPILE_WARNING:
                return 'E_COMPILE_WARNING';
            case E_USER_ERROR:
                return 'E_USER_ERROR';
            case E_USER_WARNING:
                return 'E_USER_WARNING';
            case E_USER_NOTICE:
                return 'E_USER_NOTICE';
            case E_STRICT:
                return 'E_STRICT';
            case E_RECOVERABLE_ERROR:
                return 'E_RECOVERABLE_ERROR';
            case E_DEPRECATED:
                return 'E_DEPRECATED';
            case E_USER_DEPRECATED:
                return 'E_USER_DEPRECATED';
        }

        return 'Unknown PHP error';
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>