Как мне отловить фатальную ошибку PHP (`E_ERROR`)?

Не совсем. Фатальные ошибки называются так, потому что они фатальны. От них не оправиться.

PHP не предоставляет обычных средств для обнаружения фатальных ошибок и восстановления после них. Это связано с тем, что обработка обычно не должна восстанавливаться после фатальной ошибки. Строка, соответствующая выходному буферу (как было предложено в исходной публикации, методика, описанная на PHP.net), определенно не рекомендуется. Это просто ненадежно.

Вызов функции mail () из метода обработчика ошибок тоже оказался проблематичным. Если бы у вас было много ошибок, ваш почтовый сервер был бы загружен работой, и вы могли бы оказаться с корявым почтовым ящиком. Чтобы избежать этого, вы можете рассмотреть возможность запуска cron для периодического сканирования журналов ошибок и соответствующей отправки уведомлений. Вы также можете изучить программное обеспечение для мониторинга системы, такое как Nagios.

Чтобы поговорить с битом о регистрации функции выключения:

Это правда, что вы можете зарегистрировать функцию выключения, и это хороший ответ.

Дело в том, что обычно мы не должны пытаться восстанавливаться после фатальных ошибок, особенно не используя регулярное выражение для выходного буфера. Я отвечал на принятый ответ, который связан с предложением на php.net, которое с тех пор было изменено или удалено.

Это предложение заключалось в том, чтобы использовать регулярное выражение для выходного буфера во время обработки исключений, а в случае фатальной ошибки (обнаруженной сопоставлением с любым настроенным текстом ошибки, которого вы могли ожидать), попробуйте выполнить какое-то восстановление или продолжить обработку. Это не было бы рекомендуемой практикой (я считаю, что поэтому я тоже не могу найти исходное предложение. Я либо не обращаю на него внимания, либо сообщество php его отклонило).

Возможно, стоит отметить, что более поздние версии PHP (около 5.1), похоже, вызывают функцию выключения раньше, до того, как вызывается обратный вызов буферизации вывода. В версии 5 и ранее этот порядок был обратным (за обратным вызовом буферизации вывода следовала функция выключения). Кроме того, начиная с версии 5.0.5 (что намного раньше, чем версия 5.2.3 опрашивающего), объекты выгружаются задолго до того, как вызывается зарегистрированная функция выключения, поэтому вы не сможете полагаться на свои объекты в памяти для выполнения много чего.

Таким образом, регистрация функции выключения - это нормально, но задачи, которые должна выполнять функция выключения, вероятно, ограничиваются несколькими процедурами мягкого выключения.

Ключевой вывод здесь - это всего лишь несколько мудрых слов для тех, кто наткнется на этот вопрос и увидит совет в первоначально принятом ответе. Не используйте регулярное выражение в выходном буфере.

Регистрируйте фатальные ошибки с помощью register_shutdown_function, для которого требуется 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));
    }
}

Вам нужно будет определить функции error_mail и format_error. Например:

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

Используйте Swift Mailer для записи функции error_mail.

Смотрите также:

• $ php_errormsg
• Предопределенные константы

Я только что придумал это решение (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');

Различные типы ошибок определены в Предопределенные константы.

Вы не можете создать исключение внутри зарегистрированной функции выключения, например:

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

Но вы можете захватить и перенаправить запрос на другую страницу.

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

Что ж, фатальные ошибки вроде бы можно отловить и другим способом :)

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

Мне нужно обрабатывать фатальные ошибки для производства, чтобы вместо этого отображать вывод HTML в статическом стиле 503 Служба Недоступна. Это, безусловно, разумный подход к «отлову фатальных ошибок». Вот что я сделал:

У меня есть специальная функция обработки ошибок error_handler, которая будет отображать мою HTML-страницу «503 service unavailable» на любой E_ERROR, E_USER_ERROR и т. д. Теперь она будет вызываться в функции выключения, обнаруживая мою фатальную ошибку,

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

в моей пользовательской функции error_handler, если это ошибка E_ERROR, E_USER_ERROR и т.д. Я также вызываю @ob_end_clean();, чтобы очистить буфер, тем самым удаляя сообщение PHP о «фатальной ошибке».

Обратите внимание на строгую проверку isset () и функции отключения звука @, поскольку мы не хотим, чтобы наши сценарии error_handler генерировали какие-либо ошибки.

По-прежнему соглашаясь с keparo, обнаружение фатальных ошибок лишает вас цели «FATAL error», поэтому на самом деле это не предназначено для дальнейшей обработки. Не запускайте никаких функций mail () в этом процессе завершения работы, так как вы обязательно создадите резервную копию почтового сервера или своего почтового ящика. Лучше записать эти вхождения в файл и запланировать задание cron, чтобы найти эти файлы журнал ошибок и отправить их администраторам.

Я разработал эту функцию, чтобы сделать возможным "песочницу" кода, который может вызвать фатальную ошибку. Поскольку исключения, вызванные закрытием register_shutdown_function, не генерируются из стека вызовов до фатальной ошибки, я вынужден выйти после этой функции, чтобы обеспечить единообразный способ ее использования.

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

PHP имеет обнаруживаемые фатальные ошибки. Они определены как E_RECOVERABLE_ERROR. Руководство по PHP описывает E_RECOVERABLE_ERROR как:

Catchable fatal error. It indicates that a probably dangerous error occured, but did not leave the Engine in an unstable state. If the error is not caught by a user defined handle (see also set_error_handler()), the application aborts as it was an E_ERROR.

Вы можете «поймать» эти «фатальные» ошибки, используя set_error_handler () и проверяя E_RECOVERABLE_ERROR. Я считаю полезным генерировать исключение при обнаружении этой ошибки, тогда вы можете использовать try / catch.

Этот вопрос и ответ представляют собой полезный пример: Как я могу отловить «обнаруживаемую фатальную ошибку» при хинтинге типа PHP?

Однако ошибки E_ERROR можно обработать, но нельзя исправить, поскольку механизм находится в нестабильном состоянии.

Я разработал способ перехвата всех типов ошибок в PHP (почти всех)! Я не уверен насчет E_CORE_ERROR (думаю, не будет работать только для этой ошибки)! Но для других фатальных ошибок (E_ERROR, E_PARSE, E_COMPILE ...) отлично работает, используя только одну функцию обработчика ошибок! Вот и мое решение:

Поместите следующий код в свой основной файл (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();
?>

Если вы используете PHP> = 5.1.0 Просто сделайте что-нибудь подобное с классом 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
    }
?>

Существуют определенные обстоятельства, при которых должны быть обнаружены даже фатальные ошибки (вам может потребоваться выполнить некоторую очистку перед выходом изящно и не просто умереть ...)

Я реализовал ловушку pre_system в своих приложениях CodeIgniter, чтобы я мог получать свои фатальные ошибки по электронной почте, и это помогло мне найти ошибки, о которых не сообщалось (или о которых сообщалось после того, как они были исправлены, поскольку я уже знал о них :)).

Sendemail проверяет, не сообщалось ли уже об ошибке, чтобы не отправлять вам спам с известными ошибками несколько раз.

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

Вот просто хороший трюк, чтобы получить текущий метод 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;
        }
    }
?>

Также хочу отметить, что если вы позвоните

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

PHP перестает отображать ошибку. В противном случае текст ошибки будет отправлен клиенту до вашего обработчика ошибок.

Хорошее решение, найденное в 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);
    }
}

Этот класс позволяет вам иногда запускать конкретный ErrorHandler, если он вам нужен. И тогда вы также можете остановить обработчик.

Используйте этот класс, например. нравится:

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;

Ссылка на полный код класса:
https://github.com/zendframework/zf2/blob/master/library/Zend/Stdlib/ErrorHandler.php

Возможно, лучшее решение - от Монолог:

Он также может обрабатывать FATAL_ERRORS с помощью функции register_shutdown_function. Согласно этому классу FATAL_ERROR является одним из следующих 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;
    }

    // [...]
}

Поскольку большинство ответов здесь излишне многословны, вот моя не уродливая версия ответа, получившего наибольшее количество голосов:

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

Вы не можете поймать / обработать фатальные ошибки, но вы можете зарегистрировать / сообщить о них. Для быстрой отладки я изменил один ответ на этот простой код

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

Фатальные ошибки или исправимые фатальные ошибки теперь вызывают экземпляры Error в PHP 7 или более поздние версии. Как и любые другие исключения, объекты Error могут быть перехвачены с помощью блока try/catch.

Пример:

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

Или вы можете использовать интерфейс Throwable для перехвата всех исключений.

Пример:

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

https://3v4l.org/Br0MG

Для получения дополнительной информации: http://php.net/manual/en/language.errors.php7.php