set_exception_handler - PHP code example

PHP Function Set_Exception_Handler

Exceptions are a feature in PHP that allows you to handle errors in your code without crashing your whole application. When an exception is thrown, the script stops running and jumps to the first catch block that matches the error type. This enables you to separate your error handling code from the rest of the application and makes it readable.

In most programming languages, there are different ways to handle exceptions. One common method is to surround dangerous code in a try block and a catch block. Whenever an exception occurs, the catch block will be executed and the rest of the program will continue. This is an excellent way to harden your application against bugs. However, it is very difficult to catch every possible exception, so errors sometimes slip through.

To handle uncaught errors, you can use a php function called set_exception_handler. This function sets a user-defined exception handler that is notified of all uncaught PHP errors and can then choose to halt the script (script halts) or pass the error object directly to higher level exception handlers for processing (e.g. print error message, log the error to a log file). Alternatively, you can create your own top level exception handler and implement your own error handling functions. In that case, you can customize the error message and error severity levels that should be matched with the bit masks for error level constants. Creating your own custom exception handler requires creating a custom class that can inherit properties from the core exception class and add your own functions to it.

set_exception_handler example

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 {
            $handler->setExceptionHandler($prev ?? [$handler, 'renderException']);
        }

    return $matches[1];
}

error_reporting(\E_ALL);

set_error_handler(function Dint $type, string $msg, string $file, int $line) {
    throw new \ErrorException($msg, 0, $type, $file, $line);
});

set_exception_handler(function DThrowable $exception) {
    echo "\n";

    $cause = $exception;
    $root = true;

    while (null !== $cause) {
        if (!$root) {
            echo "Caused by\n";
        }

        echo $cause::class.': '.$cause->getMessage()."\n";

        public function log($level, $message, array $context = []): void
        {
            if (0 !== strpos($message, 'Deprecated: ')) {
                echo 'LOG: ', $message, "\n";
            }
        }
    }
}

$_SERVER['NO_COLOR'] = '1';
set_exception_handler(function D$e) { echo "EHLO\n"; throw $e; });
ErrorHandler::register()->setDefaultLogger(new TestLogger());

throw new \Exception('foo');
?> --EXPECTF-- LOG: Uncaught Exception: foo EHLO Exception {%S #message: "foo" #code: 0 #file: "%s" #line: 27 }

if ('cli' !== \PHP_SAPI) {
    throw new Exception('This script must be run from the command line.');
}

error_reporting(\E_ALL);

set_error_handler(static function Dint $type, string $msg, string $file, int $line): void {
    throw new \ErrorException($msg, 0, $type, $file, $line);
});

set_exception_handler(static function DThrowable $exception): void {
    echo "\n";

    $cause = $exception;
    $root = true;

    while (null !== $cause) {
        if (!$root) {
            echo "Caused by\n";
        }

        echo $cause::class.': '.$cause->getMessage()."\n";

$input ??= new ArgvInput();
        $output ??= new ConsoleOutput();

        $renderException = function D\Throwable $e) use ($output) {
            if ($output instanceof ConsoleOutputInterface) {
                $this->renderThrowable($e, $output->getErrorOutput());
            } else {
                $this->renderThrowable($e, $output);
            }
        };
        if ($phpHandler = set_exception_handler($renderException)) {
            restore_exception_handler();
            if (!\is_array($phpHandler) || !$phpHandler[0] instanceof ErrorHandler) {
                $errorHandler = true;
            } elseif ($errorHandler = $phpHandler[0]->setExceptionHandler($renderException)) {
                $phpHandler[0]->setExceptionHandler($errorHandler);
            }
        }

        $this->configureIO($input, $output);

        try {

$vendor = __DIR__;
while (!file_exists($vendor.'/vendor')) {
    $vendor = \dirname($vendor);
}
require $vendor.'/vendor/autoload.php';

Debug::enable();
ini_set('display_errors', 0);

$eHandler = set_error_handler('var_dump');
$xHandler = set_exception_handler('var_dump');

var_dump([
    $eHandler[0] === $xHandler[0] ? 'Error and exception handlers do match' : 'Error and exception handlers are different',
]);

$eHandler[0]->setExceptionHandler('print_r');

if (true) {
    class Broken implements \JsonSerializable
    {
    }
}

<?php
namespace Symfony\Component\ErrorHandler;

$vendor = __DIR__;
while (!file_exists($vendor.'/vendor')) {
    $vendor = \dirname($vendor);
}
require $vendor.'/vendor/autoload.php';

set_error_handler('var_dump');
set_exception_handler('var_dump');

ErrorHandler::register(null, false);

if (true) {
    class foo extends missing
    {
    }
}
--EXPECTF--
object(Symfony\Component\ErrorHandler\Error\ClassNotFoundError)#%d (7) {   ["message":protected]=>

        ini_set('opcache.validate_timestamps', 'on');
        ini_set('opcache.revalidate_freq', 0);
      }
      else {
        // Ensure that no other code defines this.         define('DRUPAL_TEST_IN_CHILD_SITE', FALSE);
      }
    }

    // Set the Drupal custom error handler.     set_error_handler('_drupal_error_handler');
    set_exception_handler('_drupal_exception_handler');

    static::$isEnvironmentInitialized = TRUE;
  }

  /** * Locate site path and initialize settings singleton. * * @param \Symfony\Component\HttpFoundation\Request $request * The current request. * * @throws \Symfony\Component\HttpKernel\Exception\BadRequestHttpException * In case the host name in the request is not trusted. */

    private string|object|null $earlyHandler;
    private ?\Closure $exceptionHandler;
    private bool $firstCall = true;
    private bool $hasTerminatedWithException = false;

    /** * @param callable|null $exceptionHandler A handler that must support \Throwable instances that will be called on Exception */
    public function __construct(callable $exceptionHandler = null)
    {
        $handler = set_exception_handler('is_int');
        $this->earlyHandler = \is_array($handler) ? $handler[0] : null;
        restore_exception_handler();

        $this->exceptionHandler = null === $exceptionHandler ? null : $exceptionHandler(...);
    }

    /** * Configures the error handler. */
    public function configure(object $event = null): void
    {

class DebugHandlersListenerTest extends TestCase
{
    public function testConfigure()
    {
        $userHandler = static fn () => null;
        $listener = new DebugHandlersListener($userHandler);
        $eHandler = new ErrorHandler();

        $exception = null;
        set_error_handler([$eHandler, 'handleError']);
        set_exception_handler([$eHandler, 'handleException']);
        try {
            $listener->configure();
        } catch (\Exception $exception) {
        } finally {
            restore_exception_handler();
            restore_error_handler();
        }

        if (null !== $exception) {
            throw $exception;
        }

/** * Responsible for registering the error, exception and shutdown * handling of our application. * * @codeCoverageIgnore * * @return void */
    public function initialize()
    {
        set_exception_handler([$this, 'exceptionHandler']);
        set_error_handler([$this, 'errorHandler']);
        register_shutdown_function([$this, 'shutdownHandler']);
    }

    /** * Catches any uncaught errors and exceptions, including most Fatal errors * (Yay PHP7!). Will log the error, display it if display_errors is on, * and fire an event that allows custom actions to be taken at this point. * * @return void * @phpstan-return never|void */

/** * @return void */
    public function onKernelException(ExceptionEvent $event)
    {
        if (null === $this->controller) {
            return;
        }

        $throwable = $event->getThrowable();

        if ($exceptionHandler = set_exception_handler(var_dump(...))) {
            restore_exception_handler();
            if (\is_array($exceptionHandler) && $exceptionHandler[0] instanceof ErrorHandler) {
                $throwable = $exceptionHandler[0]->enhanceError($event->getThrowable());
            }
        }

        $request = $this->duplicateRequest($throwable, $event->getRequest());

        try {
            $response = $event->getKernel()->handle($request, HttpKernelInterface::SUB_REQUEST, false);
        } catch (\Exception $e) {