Jak wyłapać błąd krytyczny PHP (`E_ERROR`)?

Mogę użyć, set_error_handler()aby wyłapać większość błędów PHP, ale to nie działa na fatalne (E_ERROR błędów ), takich jak wywołanie funkcji, która nie istnieje. Czy istnieje inny sposób na wyłapanie tych błędów?

Próbuję wywołać mail()wszystkie błędy i korzystam z PHP 5.2.3.

Loguj krytyczne błędy używając register_shutdown_function, który wymaga 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));
    }
}

Będziesz musiał zdefiniować funkcje error_maili format_error. Na przykład:

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

Użyj Swift Mailer, aby napisać error_mailfunkcję.

Zobacz też:

• $ php_errormsg
• Predefiniowane stałe

Właśnie wymyśliłem to rozwiązanie (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');

Różne typy błędów są zdefiniowane w predefiniowanych stałych .

PHP nie zapewnia konwencjonalnych sposobów wychwytywania i odzyskiwania po błędach krytycznych. Wynika to z faktu, że przetwarzanie zwykle nie powinno być odzyskiwane po wystąpieniu błędu krytycznego. Ciąg pasujący do bufora wyjściowego (jak sugeruje oryginalny post technika opisana na PHP.net) jest zdecydowanie odradzany. To po prostu niewiarygodne.

Problematyczne jest również wywoływanie funkcji mail () z poziomu metody obsługi błędów. Gdybyś miał dużo błędów, twój serwer pocztowy byłby załadowany pracą i mógłbyś znaleźć się z gnarly skrzynką odbiorczą. Aby tego uniknąć, możesz rozważyć uruchomienie crona, aby okresowo skanować dzienniki błędów i odpowiednio wysyłać powiadomienia. Możesz także zajrzeć do oprogramowania do monitorowania systemu, takiego jak Nagios .

Aby porozmawiać o rejestracji funkcji zamykania:

To prawda, że ​​możesz zarejestrować funkcję zamykania, a to dobra odpowiedź.

Chodzi o to, że zazwyczaj nie powinniśmy próbować przywracać sprawności po błędach krytycznych, zwłaszcza nie używając wyrażenia regularnego w buforze wyjściowym. Odpowiedziałem na zaakceptowaną odpowiedź , która łączyła się z sugestią na php.net, która została zmieniona lub usunięta.

Ta sugestia polegała na zastosowaniu wyrażenia regularnego względem bufora wyjściowego podczas obsługi wyjątków, aw przypadku błędu krytycznego (wykrytego przez dopasowanie do dowolnego skonfigurowanego tekstu błędu, którego można się spodziewać), spróbuj wykonać pewnego rodzaju odzyskiwanie lub dalsze przetwarzanie. To nie byłaby zalecana praktyka (uważam, że dlatego też nie mogę znaleźć oryginalnej sugestii. Albo przeoczam ją, albo społeczność php zestrzeliła ją).

Warto zauważyć, że nowsze wersje PHP (około 5.1) wydają się wcześniej wywoływać funkcję zamykania, zanim zostanie wywołane wywołanie zwrotne buforowania wyjścia. W wersji 5 i wcześniejszych ta kolejność była odwrotna (po wywołaniu zwrotnym buforowania danych wyjściowych nastąpiła funkcja zamykania). Ponadto, ponieważ około 5.0.5 (czyli znacznie wcześniej niż wersja pytającego 5.2.3), obiekty są rozładowywane na długo przed wywołaniem zarejestrowanej funkcji zamykania, więc nie będzie można polegać na obiektach w pamięci dużo czegokolwiek.

Rejestracja funkcji zamykania jest więc w porządku, ale zadania, które powinna wykonać funkcja zamykania, prawdopodobnie ograniczają się do kilku delikatnych procedur zamykania.

Kluczową sprawą tutaj są tylko słowa mądrości dla każdego, kto natknie się na to pytanie i zapozna się z radą w pierwotnie przyjętej odpowiedzi. Nie regexuj bufora wyjściowego.

Wydaje się, że możliwe jest złapanie krytycznych błędów w inny sposób :)

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

Błędy krytyczne lub możliwe do odzyskania błędy krytyczne generują teraz instancje Errorw PHP 7 lub wyższych wersjach . Jak wszystkie inne wyjątki, Errorobiekty można złapać za pomocą try/catchbloku.

Przykład:

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

Lub możesz użyć Throwableinterfejsu, aby złapać wszystkie wyjątki.

Przykład:

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

https://3v4l.org/Br0MG

Aby uzyskać więcej informacji: http://php.net/manual/en/language.errors.php7.php

Opracowałem sposób na wyłapanie wszystkich typów błędów w PHP (prawie wszystkie)! Nie mam pewności co do E_CORE_ERROR (myślę, że nie będzie działać tylko w przypadku tego błędu)! Ale w przypadku innych błędów krytycznych (E_ERROR, E_PARSE, E_COMPILE ...) działa dobrze przy użyciu tylko jednej funkcji obsługi błędów! Oto moje rozwiązanie:

Umieść następujący kod w głównym pliku (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();
?>

Nie możesz wychwycić / obsłużyć krytycznych błędów, ale możesz je zalogować / zgłosić. W celu szybkiego debugowania zmodyfikowałem jedną odpowiedź na ten prosty kod

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

Nie można wrzucić wyjątku do zarejestrowanej funkcji zamykania w następujący sposób:

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

Ale możesz przechwytywać i przekierowywać żądania na inną stronę.

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

Jeśli używasz PHP> = 5.1.0 Po prostu zrób coś takiego z klasą 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
    }
?>

Ładne rozwiązanie znalezione w 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);
    }
}

Ta klasa pozwala ErrorHandlerczasem rozpocząć konkretną, jeśli jest to potrzebne. Następnie możesz zatrzymać Handlera.

Użyj tej klasy, np. W ten sposób:

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;

Link do pełnego kodu klasy:
https://github.com/zendframework/zf2/blob/master/library/Zend/Stdlib/ErrorHandler.php

Być może lepszym rozwiązaniem jest to od Monolog :

Może również obsługiwać FATAL_ERRORS za pomocą register_shutdown_functionfunkcji. Według tej klasy FATAL_ERROR jest jedną z poniższych 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;
    }

    // [...]
}

Muszę obsłużyć krytyczne błędy związane z produkcją, aby zamiast tego wyświetlić statyczny wynik HTML 503 Usługa niedostępna . Jest to z pewnością rozsądne podejście do „łapania błędów krytycznych”. Oto co zrobiłem:

Mam niestandardową funkcję obsługi błędów „moduł obsługi błędów”, która wyświetla moją stronę HTML „niedostępna usługa 503” na dowolnym elemencie E_ERROR, E_USER_ERROR itp. Zostanie ona teraz wywołana w funkcji zamykania, wychwytując mój błąd krytyczny,

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

w mojej niestandardowej funkcji modułu obsługi błędów, jeśli błąd to E_ERROR, E_USER_ERROR itp. Również wywołuję @ob_end_clean(); aby opróżnić bufor, usuwając w ten sposób komunikat „fatal error” PHP.

Zwróć uwagę na funkcje ścisłego sprawdzania i @wyciszania funkcji isset (), ponieważ nie chcemy, aby nasze skrypty obsługi błędów generowały błędy.

Wciąż zgadzając się z Keparo, łapanie błędów krytycznych nie pozwala na osiągnięcie celu „FATAL error”, więc tak naprawdę nie jest przeznaczone do dalszego przetwarzania. Nie uruchamiaj żadnych funkcji mail () w tym procesie zamykania, ponieważ z pewnością utworzysz kopię zapasową serwera pocztowego lub skrzynki odbiorczej. Raczej zalogować tych zdarzeń do pliku i zaplanować cron zadanie, aby znaleźć tych error.log plików i wysłać je do administratorów.

PHP ma krytyczne błędy krytyczne. Są one zdefiniowane jako E_RECOVERABLE_ERROR. Podręcznik PHP opisuje E_RECOVERABLE_ERROR jako:

Łapalny błąd krytyczny. Wskazuje, że wystąpił prawdopodobnie niebezpieczny błąd, ale nie pozostawił silnika w niestabilnym stanie. Jeśli błąd nie zostanie przechwycony przez uchwyt zdefiniowany przez użytkownika (patrz także set_error_handler () ), aplikacja przerywa, ponieważ była to E_ERROR.

Możesz „złapać” te „krytyczne” błędy, używając set_error_handler () i sprawdzając E_RECOVERABLE_ERROR. Uważam, że przydatne jest zgłoszenie wyjątku, gdy ten błąd zostanie wykryty, wtedy możesz użyć try / catch.

To pytanie i odpowiedź stanowi przydatny przykład: Jak mogę złapać „krytyczny błąd krytyczny” na podpowiedzi typu PHP?

Błędy E_ERROR można jednak obsłużyć, ale nie można ich odzyskać, ponieważ silnik jest w niestabilnym stanie.

Oto po prostu fajna sztuczka, aby uzyskać bieżącą metodę modułu obsługi błędów =)

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

Również chcę zauważyć, że jeśli zadzwonisz

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

PHP przestaje wyświetlać błąd. W przeciwnym razie tekst błędu zostanie wysłany do klienta przed obsługą błędów.

Ponieważ większość odpowiedzi tutaj jest niepotrzebnie pełna, oto moja nieprzyzwoita wersja najlepiej głosowanej odpowiedzi:

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

Nie całkiem. Błędy krytyczne nazywane są tak, ponieważ są śmiertelne. Nie możesz się od nich odzyskać.

Opracowałem tę funkcję, aby umożliwić „piaskownicę” kodu, który może spowodować błąd krytyczny. Ponieważ wyjątki wyrzucone z zamknięcia register_shutdown_functionnie są emitowane ze stosu wywołań błędów przed śmiercią, jestem zmuszony wyjść z tej funkcji, aby zapewnić jednolity sposób korzystania z niej.

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

Są pewne okoliczności, w których należy wychwycić nawet fatalne błędy (być może trzeba będzie trochę posprzątać przed wyjściem z gracją i nie tylko umrzeć ...).

Zaimplementowałem hak pre_system w moim CodeIgniter aplikacjach , dzięki czemu mogę otrzymywać krytyczne błędy za pośrednictwem e-maili, a to pomogło mi znaleźć błędy, które nie zostały zgłoszone (lub zostały zgłoszone po ich naprawieniu, jak już o nich wiedziałem :)).

Sendemail sprawdza, czy błąd został już zgłoszony, aby nie wysyłać spamu znanymi błędami wiele razy.

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