Как я могу поймать PHP фатальную ошибку

Question

Я могу использовать set_error_handler() для перехвата большинства ошибок PHP, но это не работает для фатальных (E_ERROR) ошибок, таких как вызов несуществующей функции. Есть ли другой способ отловить эти ошибки?

Я пытаюсь вызвать mail() для всех ошибок и использую PHP 5.2.3.

Answer 1

Регистрируйте фатальные ошибки, используя 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 = "
    
        ItemDescription
        
            
                Error
                $errstr

Errno

$errno

Файл $ errfile Line $ errline Трассировка

$trace

"; вернуть $ content; }

Используйте Swift Mailer , чтобы написать функцию error_mail.

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

• http://php.net/manual/en/reserved.variables.phperrormsg.php
• http://php.net/manual/en/errorfunc.constants.php

Answer 2

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

Различные типы ошибок определены в http://www.php.net/manual/en/errorfunc.constants.php

Answer 3

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

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

---

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

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

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

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

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

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

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

Answer 4

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

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;

}

Answer 5

Я разработал способ перехвата всех типов ошибок в 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();

?>

Надеюсь, это поможет многим людям! Я слишком долго искал это решение и не нашел! Тогда я разработал один!

Answer 6

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

<code>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 "

"; умереть; } } register_shutdown_function ( '__ fatalHandler');

Answer 7

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

<?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();
       # raport the event, send email etc.
       header("Location: http://localhost/error-capture");
       # from /error-capture, you can use another redirect, to e.g. home page
    }
}
register_shutdown_function('shutdown');

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

Answer 8

Фатальные ошибки или восстанавливаемые фатальные ошибки теперь генерируют 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

Answer 9

Если вы используете 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 ur error handle
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
}

?>

Answer 10

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

Возможно, лучшим решением будет решение из Monolog :

Ссылка на полный код класса:
https://github.com/Seldaek/monolog/blob/master/src/Monolog/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;
    }

    // [...]
}