Comment attraper une erreur PHP fatale (`E_ERROR`)?

Je peux utiliser set_error_handler()pour attraper la plupart des erreurs PHP, mais cela ne fonctionne pas pour les E_ERRORerreurs fatales ( ), telles que l'appel d'une fonction qui n'existe pas. Existe-t-il un autre moyen de détecter ces erreurs?

J'essaie d'appeler mail()pour toutes les erreurs et j'exécute PHP 5.2.3.

Consigner les erreurs fatales en utilisant le register_shutdown_function, qui nécessite 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));
    }
}

Vous devrez définir les fonctions error_mailet format_error. Par exemple:

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;
}

Utilisez Swift Mailer pour écrire la error_mailfonction.

Voir également:

• $ php_errormsg
• Constantes prédéfinies

Je viens de proposer cette solution (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');

Différents types d'erreur sont définis dans Constantes prédéfinies .

PHP ne fournit pas de moyens conventionnels pour détecter et récupérer des erreurs fatales. En effet, le traitement ne doit généralement pas être récupéré après une erreur fatale. Une chaîne correspondant à un tampon de sortie (comme suggéré par le post original, la technique décrite sur PHP.net) est définitivement mal avisée. Ce n'est tout simplement pas fiable.

L'appel de la fonction mail () à partir d'une méthode de gestion d'erreurs s'avère également problématique. Si vous aviez beaucoup d'erreurs, votre serveur de messagerie serait chargé de travail et vous pourriez vous retrouver avec une boîte de réception noueuse. Pour éviter cela, vous pouvez envisager d'exécuter un cron pour analyser régulièrement les journaux d'erreurs et envoyer des notifications en conséquence. Vous voudrez peut-être également examiner les logiciels de surveillance du système, tels que Nagios .

Pour parler un peu de l'enregistrement d'une fonction d'arrêt:

Il est vrai que vous pouvez enregistrer une fonction d'arrêt, et c'est une bonne réponse.

Le point ici est que nous ne devrions généralement pas essayer de récupérer des erreurs fatales, surtout pas en utilisant une expression régulière contre votre tampon de sortie. Je répondais à la réponse acceptée , qui était liée à une suggestion sur php.net qui a depuis été modifiée ou supprimée.

Cette suggestion était d'utiliser une expression régulière contre le tampon de sortie lors de la gestion des exceptions, et dans le cas d'une erreur fatale (détectée par la correspondance avec le texte d'erreur configuré que vous attendez), essayez de faire une sorte de récupération ou de traitement continu. Ce ne serait pas une pratique recommandée (je crois que c'est pourquoi je ne trouve pas la suggestion originale aussi. Je l'ignore ou la communauté php l'a abattue).

Il convient de noter que les versions les plus récentes de PHP (environ 5.1) semblent appeler la fonction d'arrêt plus tôt, avant que le rappel de la mise en mémoire tampon de sortie ne soit invoqué. Dans la version 5 et les versions antérieures, cet ordre était l'inverse (le rappel de mise en mémoire tampon de sortie était suivi de la fonction d'arrêt). De plus, depuis environ 5.0.5 (qui est beaucoup plus tôt que la version 5.2.3 de l'interrogateur), les objets sont déchargés bien avant l'appel d'une fonction d'arrêt enregistrée, vous ne pourrez donc pas compter sur vos objets en mémoire pour le faire. beaucoup de tout.

L'enregistrement d'une fonction d'arrêt est donc correct, mais le type de tâches qui devraient être effectuées par une fonction d'arrêt est probablement limité à une poignée de procédures d'arrêt en douceur.

La clé à retenir ici n'est que quelques mots de sagesse pour quiconque bute sur cette question et voit les conseils dans la réponse initialement acceptée. Ne pas regex votre tampon de sortie.

Eh bien, il semble possible d'attraper des erreurs fatales d'une autre manière :)

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;
}

Les erreurs fatales ou des erreurs fatales récupérables jettent maintenant les instances de Erroren PHP 7 ou versions supérieures . Comme toutes les autres exceptions, les Errorobjets peuvent être interceptés à l'aide d'un try/catchbloc.

Exemple:

<?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

Ou vous pouvez utiliser l' Throwableinterface pour intercepter toutes les exceptions.

Exemple:

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

https://3v4l.org/Br0MG

Pour plus d'informations: http://php.net/manual/en/language.errors.php7.php

J'ai développé un moyen d'attraper tous les types d'erreur en PHP (presque tous)! Je n'ai aucune certitude sur E_CORE_ERROR (je pense que cela ne fonctionnera pas uniquement pour cette erreur)! Mais, pour d'autres erreurs fatales (E_ERROR, E_PARSE, E_COMPILE ...) fonctionne très bien en utilisant une seule fonction de gestion d'erreur! Voilà ma solution:

Mettez ce code suivant sur votre fichier 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();
?>

Vous ne pouvez pas attraper / gérer les erreurs fatales, mais vous pouvez les enregistrer / signaler. Pour un débogage rapide, j'ai modifié une réponse à ce code 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');

Vous ne pouvez pas lancer d'exception dans une fonction d'arrêt enregistrée comme celle-ci:

<?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
    }
?>

Mais vous pouvez capturer et rediriger la demande vers une autre page.

<?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 vous utilisez PHP> = 5.1.0 Faites simplement quelque chose comme ça avec la classe 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
    }
?>

Belle solution trouvée dans 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);
    }
}

Cette classe vous permet de démarrer le spécifique ErrorHandlerparfois si vous en avez besoin. Et puis, vous pouvez également arrêter le gestionnaire.

Utilisez cette classe par exemple comme ceci:

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;

Lien vers le code complet de classe:
https://github.com/zendframework/zf2/blob/master/library/Zend/Stdlib/ErrorHandler.php

Une solution peut-être meilleure est celle de Monolog :

Il peut également gérer FATAL_ERRORS à l'aide de la register_shutdown_functionfonction. Selon cette classe, FATAL_ERROR est l'un des suivants 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;
    }

    // [...]
}

J'ai besoin de gérer les erreurs fatales pour la production afin d'afficher à la place une sortie HTML 503 de style statique non disponible . C'est sûrement une approche raisonnable pour "détecter les erreurs fatales". Voici ce que j'ai fait:

J'ai une fonction personnalisée de gestion des erreurs "error_handler" qui affichera ma page HTML "503 service non disponible" sur n'importe quelle E_ERROR, E_USER_ERROR, etc.

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');

dans ma fonction personnalisée error_handler, si l'erreur est E_ERROR, E_USER_ERROR, etc. J'appelle également @ob_end_clean();pour vider le tampon, supprimant ainsi le message "erreur fatale" de PHP.

Prenez note des fonctions strictes de vérification et de désactivation de isset () @car nous ne voulons pas que nos scripts error_handler génèrent des erreurs.

En étant toujours d'accord avec keparo, la capture d'erreurs fatales va à l'encontre du but de "l'erreur fatale", donc il n'est pas vraiment destiné à vous de poursuivre le traitement. N'exécutez aucune fonction mail () dans ce processus d'arrêt car vous sauvegarderez certainement le serveur de messagerie ou votre boîte de réception. Consignez plutôt ces occurrences dans un fichier et planifiez un travail cron pour trouver ces fichiers error.log et les envoyer par courrier aux administrateurs.

PHP a des erreurs fatales capturables. Ils sont définis comme E_RECOVERABLE_ERROR. Le manuel PHP décrit un E_RECOVERABLE_ERROR comme:

Erreur fatale capturable. Il indique qu'une erreur probablement dangereuse s'est produite, mais n'a pas laissé le moteur dans un état instable. Si l'erreur n'est pas détectée par un descripteur défini par l'utilisateur (voir aussi set_error_handler () ), l'application s'interrompt car il s'agissait d'un E_ERROR.

Vous pouvez "intercepter" ces erreurs "fatales" en utilisant set_error_handler () et en recherchant E_RECOVERABLE_ERROR. Je trouve utile de lever une exception lorsque cette erreur est détectée, vous pouvez alors utiliser try / catch.

Cette question et réponse fournit un exemple utile: Comment puis-je détecter une "erreur fatale capturable" sur les indications de type PHP?

Cependant, les erreurs E_ERROR peuvent être gérées, mais pas récupérées car le moteur est dans un état instable.

Voici juste une bonne astuce pour obtenir la méthode error_handler actuelle =)

<?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;
        }
    }
?>

Je veux aussi noter que si vous appelez

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

PHP cesse d'afficher l'erreur. Sinon, le texte d'erreur sera envoyé au client avant votre gestionnaire d'erreurs.

Puisque la plupart des réponses ici sont inutilement verbeuses, voici ma version non laide de la réponse la plus votée:

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");

Pas vraiment. Les erreurs fatales sont appelées ainsi, car elles sont fatales. Vous ne pouvez pas vous remettre d'eux.

J'ai développé cette fonction pour rendre possible le code "sandbox" qui pourrait provoquer une erreur fatale. Depuis les exceptions levées de la fermetureregister_shutdown_function ne sont pas émises à partir de la pile d'appels d'erreur pré-fatale, je suis obligé de quitter après cette fonction pour fournir un moyen uniforme de l'utiliser.

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();
}

Il y a certaines circonstances dans lesquelles même des erreurs fatales devraient être détectées (vous devrez peut-être faire un peu de nettoyage avant de sortir gracieusement et ne pas simplement mourir ..).

J'ai implémenté un hook pre_system dans mon CodeIgniter applications afin que je puisse obtenir mes erreurs fatales par e-mails, ce qui m'a aidé à trouver des bogues qui n'ont pas été signalés (ou qui ont été signalés après leur correction, car je les connaissais déjà :)).

Sendemail vérifie si l'erreur a déjà été signalée afin de ne pas vous spammer plusieurs fois avec des erreurs connues.

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();
    }
}