<form method="POST">
    <h3>Editing: HandleExceptions.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Foundation\Bootstrap;

use ErrorException;
use Exception;
use Illuminate\Contracts\Debug\ExceptionHandler;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Log\LogManager;
use Monolog\Handler\NullHandler;
use Symfony\Component\Console\Output\ConsoleOutput;
use Symfony\Component\ErrorHandler\Error\FatalError;
use Throwable;

class HandleExceptions
{
    /**
     * Reserved memory so that errors can be displayed properly on memory exhaustion.
     *
     * @var string
     */
    public static $reservedMemory;

    /**
     * The application instance.
     *
     * @var \Illuminate\Contracts\Foundation\Application
     */
    protected $app;

    /**
     * Bootstrap the given application.
     *
     * @param  \Illuminate\Contracts\Foundation\Application  $app
     * @return void
     */
    public function bootstrap(Application $app)
    {
        self::$reservedMemory = str_repeat('x', 32768);

        $this-&gt;app = $app;

        error_reporting(-1);

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

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

        register_shutdown_function([$this, 'handleShutdown']);

        if (! $app-&gt;environment('testing')) {
            ini_set('display_errors', 'Off');
        }
    }

    /**
     * Report PHP deprecations, or convert PHP errors to ErrorException instances.
     *
     * @param  int  $level
     * @param  string  $message
     * @param  string  $file
     * @param  int  $line
     * @param  array  $context
     * @return void
     *
     * @throws \ErrorException
     */
    public function handleError($level, $message, $file = '', $line = 0, $context = [])
    {
        if ($this-&gt;isDeprecation($level)) {
            return $this-&gt;handleDeprecation($message, $file, $line);
        }

        if (error_reporting() &amp; $level) {
            throw new ErrorException($message, 0, $level, $file, $line);
        }
    }

    /**
     * Reports a deprecation to the &quot;deprecations&quot; logger.
     *
     * @param  string  $message
     * @param  string  $file
     * @param  int  $line
     * @return void
     */
    public function handleDeprecation($message, $file, $line)
    {
        if (! class_exists(LogManager::class)
            || ! $this-&gt;app-&gt;hasBeenBootstrapped()
            || $this-&gt;app-&gt;runningUnitTests()
        ) {
            return;
        }

        try {
            $logger = $this-&gt;app-&gt;make(LogManager::class);
        } catch (Exception $e) {
            return;
        }

        $this-&gt;ensureDeprecationLoggerIsConfigured();

        with($logger-&gt;channel('deprecations'), function ($log) use ($message, $file, $line) {
            $log-&gt;warning(sprintf('%s in %s on line %s',
                $message, $file, $line
            ));
        });
    }

    /**
     * Ensure the &quot;deprecations&quot; logger is configured.
     *
     * @return void
     */
    protected function ensureDeprecationLoggerIsConfigured()
    {
        with($this-&gt;app['config'], function ($config) {
            if ($config-&gt;get('logging.channels.deprecations')) {
                return;
            }

            $this-&gt;ensureNullLogDriverIsConfigured();

            $driver = $config-&gt;get('logging.deprecations') ?? 'null';

            $config-&gt;set('logging.channels.deprecations', $config-&gt;get(&quot;logging.channels.{$driver}&quot;));
        });
    }

    /**
     * Ensure the &quot;null&quot; log driver is configured.
     *
     * @return void
     */
    protected function ensureNullLogDriverIsConfigured()
    {
        with($this-&gt;app['config'], function ($config) {
            if ($config-&gt;get('logging.channels.null')) {
                return;
            }

            $config-&gt;set('logging.channels.null', [
                'driver' =&gt; 'monolog',
                'handler' =&gt; NullHandler::class,
            ]);
        });
    }

    /**
     * Handle an uncaught exception from the application.
     *
     * Note: Most exceptions can be handled via the try / catch block in
     * the HTTP and Console kernels. But, fatal error exceptions must
     * be handled differently since they are not normal exceptions.
     *
     * @param  \Throwable  $e
     * @return void
     */
    public function handleException(Throwable $e)
    {
        self::$reservedMemory = null;

        try {
            $this-&gt;getExceptionHandler()-&gt;report($e);
        } catch (Exception $e) {
            //
        }

        if ($this-&gt;app-&gt;runningInConsole()) {
            $this-&gt;renderForConsole($e);
        } else {
            $this-&gt;renderHttpResponse($e);
        }
    }

    /**
     * Render an exception to the console.
     *
     * @param  \Throwable  $e
     * @return void
     */
    protected function renderForConsole(Throwable $e)
    {
        $this-&gt;getExceptionHandler()-&gt;renderForConsole(new ConsoleOutput, $e);
    }

    /**
     * Render an exception as an HTTP response and send it.
     *
     * @param  \Throwable  $e
     * @return void
     */
    protected function renderHttpResponse(Throwable $e)
    {
        $this-&gt;getExceptionHandler()-&gt;render($this-&gt;app['request'], $e)-&gt;send();
    }

    /**
     * Handle the PHP shutdown event.
     *
     * @return void
     */
    public function handleShutdown()
    {
        self::$reservedMemory = null;

        if (! is_null($error = error_get_last()) &amp;&amp; $this-&gt;isFatal($error['type'])) {
            $this-&gt;handleException($this-&gt;fatalErrorFromPhpError($error, 0));
        }
    }

    /**
     * Create a new fatal error instance from an error array.
     *
     * @param  array  $error
     * @param  int|null  $traceOffset
     * @return \Symfony\Component\ErrorHandler\Error\FatalError
     */
    protected function fatalErrorFromPhpError(array $error, $traceOffset = null)
    {
        return new FatalError($error['message'], 0, $error, $traceOffset);
    }

    /**
     * Determine if the error level is a deprecation.
     *
     * @param  int  $level
     * @return bool
     */
    protected function isDeprecation($level)
    {
        return in_array($level, [E_DEPRECATED, E_USER_DEPRECATED]);
    }

    /**
     * Determine if the error type is fatal.
     *
     * @param  int  $type
     * @return bool
     */
    protected function isFatal($type)
    {
        return in_array($type, [E_COMPILE_ERROR, E_CORE_ERROR, E_ERROR, E_PARSE]);
    }

    /**
     * Get an instance of the exception handler.
     *
     * @return \Illuminate\Contracts\Debug\ExceptionHandler
     */
    protected function getExceptionHandler()
    {
        return $this-&gt;app-&gt;make(ExceptionHandler::class);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>