¿Cómo puedo detectar un error fatal de PHP (`E_ERROR`)?

Puedo usar set_error_handler()para detectar la mayoría de los errores de PHP, pero no funciona para E_ERRORerrores fatales ( ), como llamar a una función que no existe. ¿Hay otra forma de detectar estos errores?

Estoy tratando de llamar mail()a todos los errores y estoy ejecutando PHP 5.2.3.

Registre errores fatales utilizando el register_shutdown_function, que requiere PHP 5.2+:

register_shutdown_function( "fatal_handler" );

function fatal_handler() {
    $errfile = "unknown file";
    $errstr  = "shutdown";
    $errno   = E_CORE_ERROR;
    $errline = 0;

    $error = error_get_last();

    if($error !== NULL) {
        $errno   = $error["type"];
        $errfile = $error["file"];
        $errline = $error["line"];
        $errstr  = $error["message"];

        error_mail(format_error( $errno, $errstr, $errfile, $errline));
    }
}

Deberá definir las funciones error_maily format_error. Por ejemplo:

function format_error( $errno, $errstr, $errfile, $errline ) {
    $trace = print_r( debug_backtrace( false ), true );

    $content = "
    <table>
        <thead><th>Item</th><th>Description</th></thead>
        <tbody>
            <tr>
                <th>Error</th>
                <td><pre>$errstr</pre></td>
            </tr>
            <tr>
                <th>Errno</th>
                <td><pre>$errno</pre></td>
            </tr>
            <tr>
                <th>File</th>
                <td>$errfile</td>
            </tr>
            <tr>
                <th>Line</th>
                <td>$errline</td>
            </tr>
            <tr>
                <th>Trace</th>
                <td><pre>$trace</pre></td>
            </tr>
        </tbody>
    </table>";
    return $content;
}

Use Swift Mailer para escribir la error_mailfunción.

Ver también:

• $ php_errormsg
• Constantes predefinidas

Se me ocurrió esta solución (PHP 5.2.0+):

function shutDownFunction() {
    $error = error_get_last();
     // Fatal error, E_ERROR === 1
    if ($error['type'] === E_ERROR) {
         // Do your stuff
    }
}
register_shutdown_function('shutDownFunction');

Se definen diferentes tipos de error en Constantes predefinidas .

PHP no proporciona medios convencionales para atrapar y recuperarse de errores fatales. Esto se debe a que el procesamiento no debe recuperarse normalmente después de un error fatal. La cadena que coincide con un búfer de salida (como sugiere la publicación original, la técnica descrita en PHP.net) es definitivamente desaconsejada. Es simplemente poco confiable.

Llamar a la función mail () desde un método de manejo de errores también resulta problemático. Si tuviera muchos errores, su servidor de correo estaría cargado de trabajo y podría encontrarse con una bandeja de entrada retorcida. Para evitar esto, puede considerar ejecutar un cron para escanear registros de errores periódicamente y enviar notificaciones en consecuencia. También es posible que desee analizar el software de monitoreo del sistema, como Nagios .

Para hablar un poco sobre el registro de una función de apagado:

Es cierto que puede registrar una función de apagado, y esa es una buena respuesta.

El punto aquí es que normalmente no deberíamos intentar recuperarnos de errores fatales, especialmente no mediante el uso de una expresión regular contra su búfer de salida. Estaba respondiendo a la respuesta aceptada , que se vinculaba con una sugerencia en php.net que desde entonces ha sido modificada o eliminada.

Esa sugerencia fue usar una expresión regular contra el búfer de salida durante el manejo de excepciones, y en el caso de un error fatal (detectado por la coincidencia con cualquier texto de error configurado que pueda esperar), intente hacer algún tipo de recuperación o procesamiento continuo. Esa no sería una práctica recomendada (creo que es por eso que no puedo encontrar la sugerencia original también. O lo estoy pasando por alto o la comunidad de php la rechazó).

Vale la pena señalar que las versiones más recientes de PHP (alrededor de 5.1) parecen llamar a la función de apagado antes, antes de que se invoque la devolución de llamada de búfer de salida. En la versión 5 y anteriores, ese orden era el inverso (la devolución de llamada de la memoria intermedia de salida fue seguida por la función de apagado). Además, desde aproximadamente 5.0.5 (que es mucho anterior a la versión 5.2.3 del interlocutor), los objetos se descargan mucho antes de que se llame a una función de apagado registrada, por lo que no podrá confiar en sus objetos en memoria para hacer mucho de cualquier cosa.

Por lo tanto, registrar una función de apagado está bien, pero el tipo de tareas que debe realizar una función de apagado probablemente se limite a un puñado de procedimientos de apagado suaves.

La clave aquí es solo algunas palabras de sabiduría para cualquiera que se tope con esta pregunta y vea el consejo en la respuesta originalmente aceptada. No regexes tu búfer de salida.

Bueno, parece posible detectar errores fatales de otra manera :)

ob_start('fatal_error_handler');

function fatal_error_handler($buffer){
    $error = error_get_last();
    if($error['type'] == 1){
        // Type, message, file, line
        $newBuffer='<html><header><title>Fatal Error </title></header>
                      <style>
                    .error_content{
                        background: ghostwhite;
                        vertical-align: middle;
                        margin:0 auto;
                        padding: 10px;
                        width: 50%;
                     }
                     .error_content label{color: red;font-family: Georgia;font-size: 16pt;font-style: italic;}
                     .error_content ul li{ background: none repeat scroll 0 0 FloralWhite;
                                border: 1px solid AliceBlue;
                                display: block;
                                font-family: monospace;
                                padding: 2%;
                                text-align: left;
                      }
                      </style>
                      <body style="text-align: center;">
                        <div class="error_content">
                             <label >Fatal Error </label>
                             <ul>
                               <li><b>Line</b> ' . $error['line'] . '</li>
                               <li><b>Message</b> ' . $error['message'] . '</li>
                               <li><b>File</b> ' . $error['file'] . '</li>
                             </ul>

                             <a href="javascript:history.back()"> Back </a>
                        </div>
                      </body></html>';

        return $newBuffer;
    }
    return $buffer;
}

Los errores fatales o errores fatales recuperables Ahora lanzan casos de Erroren PHP 7 o versiones superiores . Como cualquier otra excepción, los Errorobjetos se pueden atrapar usando un try/catchbloque.

Ejemplo:

<?php
$variable = 'not an object';

try {
    $variable->method(); // Throws an Error object in PHP 7 or higger.
} catch (Error $e) {
    // Handle error
    echo $e->getMessage(); // Call to a member function method() on string
}

https://3v4l.org/67vbk

O puede usar la Throwableinterfaz para capturar todas las excepciones.

Ejemplo:

<?php
    try {
        undefinedFunctionCall();
    } catch (Throwable $e) {
        // Handle error
        echo $e->getMessage(); // Call to undefined function undefinedFunctionCall()
    }

https://3v4l.org/Br0MG

Para más información: http://php.net/manual/en/language.errors.php7.php

¡Desarrollé una forma de detectar todos los tipos de error en PHP (casi todos)! ¡No estoy seguro acerca de E_CORE_ERROR (creo que no funcionará solo para ese error)! Pero, para otros errores fatales (E_ERROR, E_PARSE, E_COMPILE ...) funciona bien usando solo una función de controlador de errores. Ahí va mi solución:

Ponga el siguiente código en su archivo principal (index.php):

<?php
    define('E_FATAL',  E_ERROR | E_USER_ERROR | E_PARSE | E_CORE_ERROR |
            E_COMPILE_ERROR | E_RECOVERABLE_ERROR);

    define('ENV', 'dev');

    // Custom error handling vars
    define('DISPLAY_ERRORS', TRUE);
    define('ERROR_REPORTING', E_ALL | E_STRICT);
    define('LOG_ERRORS', TRUE);

    register_shutdown_function('shut');

    set_error_handler('handler');

    // Function to catch no user error handler function errors...
    function shut(){

        $error = error_get_last();

        if($error && ($error['type'] & E_FATAL)){
            handler($error['type'], $error['message'], $error['file'], $error['line']);
        }

    }

    function handler( $errno, $errstr, $errfile, $errline ) {

        switch ($errno){

            case E_ERROR: // 1 //
                $typestr = 'E_ERROR'; break;
            case E_WARNING: // 2 //
                $typestr = 'E_WARNING'; break;
            case E_PARSE: // 4 //
                $typestr = 'E_PARSE'; break;
            case E_NOTICE: // 8 //
                $typestr = 'E_NOTICE'; break;
            case E_CORE_ERROR: // 16 //
                $typestr = 'E_CORE_ERROR'; break;
            case E_CORE_WARNING: // 32 //
                $typestr = 'E_CORE_WARNING'; break;
            case E_COMPILE_ERROR: // 64 //
                $typestr = 'E_COMPILE_ERROR'; break;
            case E_CORE_WARNING: // 128 //
                $typestr = 'E_COMPILE_WARNING'; break;
            case E_USER_ERROR: // 256 //
                $typestr = 'E_USER_ERROR'; break;
            case E_USER_WARNING: // 512 //
                $typestr = 'E_USER_WARNING'; break;
            case E_USER_NOTICE: // 1024 //
                $typestr = 'E_USER_NOTICE'; break;
            case E_STRICT: // 2048 //
                $typestr = 'E_STRICT'; break;
            case E_RECOVERABLE_ERROR: // 4096 //
                $typestr = 'E_RECOVERABLE_ERROR'; break;
            case E_DEPRECATED: // 8192 //
                $typestr = 'E_DEPRECATED'; break;
            case E_USER_DEPRECATED: // 16384 //
                $typestr = 'E_USER_DEPRECATED'; break;
        }

        $message =
            '<b>' . $typestr .
            ': </b>' . $errstr .
            ' in <b>' . $errfile .
            '</b> on line <b>' . $errline .
            '</b><br/>';

        if(($errno & E_FATAL) && ENV === 'production'){

            header('Location: 500.html');
            header('Status: 500 Internal Server Error');

        }

        if(!($errno & ERROR_REPORTING))
            return;

        if(DISPLAY_ERRORS)
            printf('%s', $message);

        //Logging error on php file error log...
        if(LOG_ERRORS)
            error_log(strip_tags($message), 0);
    }

    ob_start();

    @include 'content.php';

    ob_end_flush();
?>

No puede detectar / manejar errores fatales, pero puede registrarlos / informarlos. Para una depuración rápida, modifiqué una respuesta a este código simple

function __fatalHandler()
{
    $error = error_get_last();

    // Check if it's a core/fatal error, otherwise it's a normal shutdown
    if ($error !== NULL && in_array($error['type'],
        array(E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING,
              E_COMPILE_ERROR, E_COMPILE_WARNING,E_RECOVERABLE_ERROR))) {

        echo "<pre>fatal error:\n";
        print_r($error);
        echo "</pre>";
        die;
    }
}

register_shutdown_function('__fatalHandler');

No puede lanzar una excepción dentro de una función de apagado registrada como esa:

<?php
    function shutdown() {
        if (($error = error_get_last())) {
           ob_clean();
           throw new Exception("fatal error");
        }
    }

    try {
        $x = null;
        $x->method()
    } catch(Exception $e) {
        # This won't work
    }
?>

Pero puede capturar y redirigir la solicitud a otra página.

<?php
    function shutdown() {
        if (($error = error_get_last())) {
           ob_clean();
           # Report the event, send email, etc.
           header("Location: http://localhost/error-capture");
           # From /error-capture. You can use another
           # redirect, to e.g. the home page
        }
    }
    register_shutdown_function('shutdown');

    $x = null;
    $x->method()
?>

Si está utilizando PHP> = 5.1.0 Simplemente haga algo como esto con la clase ErrorException:

<?php
    // Define an error handler
    function exception_error_handler($errno, $errstr, $errfile, $errline ) {
        throw new ErrorException($errstr, $errno, 0, $errfile, $errline);
    }

    // Set your error handler
    set_error_handler("exception_error_handler");

    /* Trigger exception */
    try
    {
        // Try to do something like finding the end of the internet
    }
    catch(ErrorException $e)
    {
        // Anything you want to do with $e
    }
?>

Buena solución encontrada en Zend Framework 2:

/**
 * ErrorHandler that can be used to catch internal PHP errors
 * and convert to an ErrorException instance.
 */
abstract class ErrorHandler
{
    /**
     * Active stack
     *
     * @var array
     */
    protected static $stack = array();

    /**
     * Check if this error handler is active
     *
     * @return bool
     */
    public static function started()
    {
        return (bool) static::getNestedLevel();
    }

    /**
     * Get the current nested level
     *
     * @return int
     */
    public static function getNestedLevel()
    {
        return count(static::$stack);
    }

    /**
     * Starting the error handler
     *
     * @param int $errorLevel
     */
    public static function start($errorLevel = \E_WARNING)
    {
        if (!static::$stack) {
            set_error_handler(array(get_called_class(), 'addError'), $errorLevel);
        }

        static::$stack[] = null;
    }

    /**
     * Stopping the error handler
     *
     * @param  bool $throw Throw the ErrorException if any
     * @return null|ErrorException
     * @throws ErrorException If an error has been catched and $throw is true
     */
    public static function stop($throw = false)
    {
        $errorException = null;

        if (static::$stack) {
            $errorException = array_pop(static::$stack);

            if (!static::$stack) {
                restore_error_handler();
            }

            if ($errorException && $throw) {
                throw $errorException;
            }
        }

        return $errorException;
    }

    /**
     * Stop all active handler
     *
     * @return void
     */
    public static function clean()
    {
        if (static::$stack) {
            restore_error_handler();
        }

        static::$stack = array();
    }

    /**
     * Add an error to the stack
     *
     * @param int    $errno
     * @param string $errstr
     * @param string $errfile
     * @param int    $errline
     * @return void
     */
    public static function addError($errno, $errstr = '', $errfile = '', $errline = 0)
    {
        $stack = & static::$stack[count(static::$stack) - 1];
        $stack = new ErrorException($errstr, 0, $errno, $errfile, $errline, $stack);
    }
}

Esta clase le permite comenzar lo específico a ErrorHandlerveces si lo necesita. Y luego también puede detener el controlador.

Use esta clase, por ejemplo, así:

ErrorHandler::start(E_WARNING);
$return = call_function_raises_E_WARNING();

if ($innerException = ErrorHandler::stop()) {
    throw new Exception('Special Exception Text', 0, $innerException);
}

// or
ErrorHandler::stop(true); // directly throws an Exception;

Enlace al código de clase completo:
https://github.com/zendframework/zf2/blob/master/library/Zend/Stdlib/ErrorHandler.php

Una solución quizás mejor es la de Monolog :

También puede manejar FATAL_ERRORS usando la register_shutdown_functionfunción. De acuerdo con esta clase, un FATAL_ERROR es uno de los siguientes array(E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR).

class ErrorHandler
{
    // [...]

    public function registerExceptionHandler($level = null, $callPrevious = true)
    {
        $prev = set_exception_handler(array($this, 'handleException'));
        $this->uncaughtExceptionLevel = $level;
        if ($callPrevious && $prev) {
            $this->previousExceptionHandler = $prev;
        }
    }

    public function registerErrorHandler(array $levelMap = array(), $callPrevious = true, $errorTypes = -1)
    {
        $prev = set_error_handler(array($this, 'handleError'), $errorTypes);
        $this->errorLevelMap = array_replace($this->defaultErrorLevelMap(), $levelMap);
        if ($callPrevious) {
            $this->previousErrorHandler = $prev ?: true;
        }
    }

    public function registerFatalHandler($level = null, $reservedMemorySize = 20)
    {
        register_shutdown_function(array($this, 'handleFatalError'));

        $this->reservedMemory = str_repeat(' ', 1024 * $reservedMemorySize);
        $this->fatalLevel = $level;
    }

    // [...]
}

Necesito manejar errores fatales para que la producción muestre en su lugar una salida HTML no disponible de servicio 503 de estilo estático . Este es sin duda un enfoque razonable para "detectar errores fatales". Esto es lo que he hecho:

Tengo una función personalizada de manejo de errores "error_handler" que mostrará mi página HTML "503 servicio no disponible" en cualquier E_ERROR, E_USER_ERROR, etc. Esto ahora se llamará en la función de apagado, detectando mi error fatal,

function fatal_error_handler() {

    if (@is_array($e = @error_get_last())) {
        $code = isset($e['type']) ? $e['type'] : 0;
        $msg = isset($e['message']) ? $e['message'] : '';
        $file = isset($e['file']) ? $e['file'] : '';
        $line = isset($e['line']) ? $e['line'] : '';
        if ($code>0)
            error_handler($code, $msg, $file, $line);
    }
}
set_error_handler("error_handler");
register_shutdown_function('fatal_error_handler');

en mi función personalizada error_handler, si el error es E_ERROR, E_USER_ERROR, etc. También llamo @ob_end_clean();para vaciar el búfer, eliminando así el mensaje de "error fatal" de PHP.

Tome nota importante de las estrictas funciones de comprobación y @silenciamiento de isset () ya que no queremos que nuestros scripts error_handler generen errores.

Al seguir de acuerdo con Keparo, detectar errores fatales no cumple con el propósito del "error FATAL", por lo que no está destinado a que realices un procesamiento posterior. No ejecute ninguna función de correo () en este proceso de apagado, ya que seguramente hará una copia de seguridad del servidor de correo o de su bandeja de entrada. En su lugar, registre estas ocurrencias en el archivo y programe un trabajo cron para encontrar estos archivos error.log y envíelos por correo a los administradores.

PHP tiene errores fatales detectables. Se definen como E_RECOVERABLE_ERROR. El manual de PHP describe un E_RECOVERABLE_ERROR como:

Error fatal capturable. Indica que ocurrió un error probablemente peligroso, pero no dejó el motor en un estado inestable. Si el error no es detectado por un identificador definido por el usuario (consulte también set_error_handler () ), la aplicación se anula ya que era un E_ERROR.

Puede "atrapar" estos errores "fatales" utilizando set_error_handler () y buscando E_RECOVERABLE_ERROR. Me resulta útil lanzar una excepción cuando se detecta este error, entonces puede usar try / catch.

Esta pregunta y respuesta proporcionan un ejemplo útil: ¿Cómo puedo detectar un "error fatal detectable" en las sugerencias de tipo PHP?

Los errores E_ERROR, sin embargo, pueden manejarse, pero no recuperarse ya que el motor está en un estado inestable.

Aquí hay un buen truco para obtener el método actual error_handler =)

<?php
    register_shutdown_function('__fatalHandler');

    function __fatalHandler()
    {
        $error = error_get_last();

        // Check if it's a core/fatal error. Otherwise, it's a normal shutdown
        if($error !== NULL && $error['type'] === E_ERROR) {

            // It is a bit hackish, but the set_exception_handler
            // will return the old handler
            function fakeHandler() { }

            $handler = set_exception_handler('fakeHandler');
            restore_exception_handler();
            if($handler !== null) {
                call_user_func(
                    $handler,
                    new ErrorException(
                        $error['message'],
                        $error['type'],
                        0,
                        $error['file'],
                        $error['line']));
            }
            exit;
        }
    }
?>

También quiero señalar que si llamas

<?php
    ini_set('display_errors', false);
?>

PHP deja de mostrar el error. De lo contrario, el texto del error se enviará al cliente antes de su controlador de errores.

Como la mayoría de las respuestas aquí son innecesariamente detalladas, aquí está mi versión no fea de la respuesta más votada:

function errorHandler($errno, $errstr, $errfile = '', $errline = 0, $errcontext = array()) {
    //Do stuff: mail, log, etc
}

function fatalHandler() {
    $error = error_get_last();
    if($error) errorHandler($error["type"], $error["message"], $error["file"], $error["line"]);
}

set_error_handler("errorHandler")
register_shutdown_function("fatalHandler");

Realmente no. Los errores fatales se llaman así, porque son fatales. No puedes recuperarte de ellos.

Desarrollé esta función para hacer posible el código "sandbox" que podría causar un error fatal. Dado que las excepciones lanzadas desde el cierre register_shutdown_functionno se emiten desde la pila de llamadas de error pre-fatal, me veo obligado a salir después de esta función para proporcionar una forma uniforme de usarla.

function superTryCatchFinallyAndExit( Closure $try, Closure $catch = NULL, Closure $finally )
{
    $finished = FALSE;
    register_shutdown_function( function() use ( &$finished, $catch, $finally ) {
        if( ! $finished ) {
            $finished = TRUE;
            print "EXPLODE!".PHP_EOL;
            if( $catch ) {
                superTryCatchFinallyAndExit( function() use ( $catch ) {
                    $catch( new Exception( "Fatal Error!!!" ) );
                }, NULL, $finally );                
            } else {
                $finally();                
            }
        }
    } );
    try {
        $try();
    } catch( Exception $e ) {
        if( $catch ) {
            try {
                $catch( $e );
            } catch( Exception $e ) {}
        }
    }
    $finished = TRUE;
    $finally();
    exit();
}

Hay ciertas circunstancias en las que se deben detectar incluso los errores fatales (es posible que deba limpiar un poco antes de salir con gracia y no simplemente morir ...).

He implementado un enlace pre_system en mis aplicaciones CodeIgniter para que pueda recibir mis errores fatales a través de correos electrónicos, y esto me ayudó a encontrar errores que no se informaron (o se informaron después de que se corrigieron, como ya sabía sobre ellos :)).

Sendemail comprueba si el error ya se ha informado para que no le envíe spam con errores conocidos varias veces.

class PHPFatalError {

    public function setHandler() {
        register_shutdown_function('handleShutdown');
    }
}

function handleShutdown() {
    if (($error = error_get_last())) {
        ob_start();
        echo "<pre>";
        var_dump($error);
        echo "</pre>";
        $message = ob_get_clean();
        sendEmail($message);
        ob_start();
        echo '{"status":"error","message":"Internal application error!"}';
        ob_flush();
        exit();
    }
}