Bir PHP ölümcül (`E_ERROR`) hatasını nasıl yakalarım?

set_error_handler()Çoğu PHP hatalarını yakalamak için kullanabilirsiniz , ancak var olmayan E_ERRORbir işlevi çağırmak gibi ölümcül ( ) hataları için çalışmaz. Bu hataları yakalamanın başka bir yolu var mı?

mail()Tüm hataları aramak için çalışıyorum ve PHP 5.2.3 çalıştırıyorum.

register_shutdown_functionPHP 5.2 ve sonraki sürümleri gerektiren önemli hataları günlüğe kaydet:

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_mailVe format_errorişlevlerini tanımlamanız gerekecektir . Örneğin:

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

İşlevi yazmak için Swift Mailer'ı kullanın error_mail.

Ayrıca bakınız:

• $ php_errormsg
• Öntanımlı Sabitler

Ben sadece bu çözümü (PHP 5.2.0+) ile geldi:

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

Önceden Tanımlı Sabitler'de farklı hata türleri tanımlanır .

PHP, ölümcül hataları yakalamak ve kurtarmak için geleneksel araçlar sağlamaz. Bunun nedeni, ölümcül bir hatadan sonra işlemenin genellikle kurtarılmaması gerektiğidir. Bir çıktı arabelleği ile eşleşen dize (orijinal yazı tarafından PHP.net'te açıklanan teknikte önerildiği gibi) kesinlikle tavsiye edilmez. Güvenilmez.

Mail () işlevini bir hata işleyici yönteminden çağırmak da sorunludur. Çok fazla hatayla karşılaşırsanız, posta sunucunuz işe yüklenir ve kendinizi korkunç bir gelen kutusuyla bulabilirsiniz. Bunu önlemek için, hata günlüklerini düzenli olarak taramak ve buna göre bildirim göndermek için bir cron çalıştırmayı düşünebilirsiniz. Nagios gibi sistem izleme yazılımlarına da bakmak isteyebilirsiniz .

Bir kapatma işlevinin kaydedilmesi hakkında biraz konuşmak için:

Bir kapatma işlevi kaydedebileceğiniz doğrudur ve bu iyi bir yanıttır.

Buradaki nokta, özellikle çıktı tamponunuza karşı düzenli bir ifade kullanarak değil, ölümcül hatalardan kurtulmaya çalışmamamız gerektiğidir. Php.net üzerinde değiştirilmiş veya kaldırılmış bir öneriyle bağlantılı olarak kabul edilen cevaba yanıt veriyordum.

Bu öneri, özel durum işleme sırasında çıktı arabelleğine bir normal ifade kullanmaktı ve önemli bir hata olması durumunda (beklediğiniz yapılandırılmış hata metniyle eşleştirme tarafından algılanıyorsa), bir tür kurtarma veya devam eden işlem yapmaya çalışın. Bu önerilen bir uygulama olmaz (Ben de bu yüzden orijinal öneri bulamıyorum inanıyorum. Ya ben ya gözden, ya da php topluluk vuruldu).

PHP'nin daha yeni sürümlerinin (yaklaşık 5.1), çıktı arabelleğe alma geri çağrılmasını sağlamadan önce kapatma işlevini daha önce çağırdığını belirtmek gerekir. Sürüm 5 ve önceki sürümlerde, bu sıra tersidir (çıktı arabelleğe alma geri aramasını ardından kapatma işlevi). Ayrıca, yaklaşık 5.0.5 (sorucının 5.2.3 sürümünden çok daha erken) olduğundan, kayıtlı bir kapatma işlevi çağrılmadan önce nesneler çok iyi kaldırılır, bu nedenle yapmak için bellek içi nesnelerinize güvenemezsiniz. çok şey var.

Bu nedenle, bir kapatma işlevinin kaydedilmesi iyidir, ancak bir kapatma işlevi tarafından gerçekleştirilmesi gereken görevler muhtemelen bir avuç nazik kapatma prosedürüyle sınırlıdır.

Buradaki anahtar teslim, bu soruya tökezleyen ve ilk kabul edilen cevapta tavsiyeyi gören herkes için sadece bazı bilgelik sözleridir. Çıktı tamponunuzu düzenli olarak düzenlemeyin.

Ölümcül hataları başka türlü yakalamak mümkün görünüyor :)

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

Ölümcül hata veya geri kazanılabilir ölümcül hataları artık örneklerini atmak Erroriçinde PHP 7 veya daha yüksek sürümleri . Diğer istisnalar gibi, Errornesneler bir try/catchblok kullanılarak yakalanabilir .

Misal:

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

Veya Throwabletüm istisnaları yakalamak için arayüzü kullanabilirsiniz .

Misal:

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

https://3v4l.org/Br0MG

Daha fazla bilgi için: http://php.net/manual/en/language.errors.php7.php

PHP tüm hata türlerini yakalamak için bir yol geliştirdim (neredeyse hepsi)! E_CORE_ERROR hakkında hiç emin değilim (Bence sadece bu hata için işe yaramaz)! Ancak, diğer önemli hatalar için (E_ERROR, E_PARSE, E_COMPILE ...) sadece bir hata işleyici işlevi kullanarak iyi çalışır! İşte benim çözümüm:

Bu kodu ana dosyanıza (index.php) yerleştirin:

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

Önemli hataları yakalayamaz / işleyemezsiniz, ancak bunları günlüğe kaydedebilir / bildirebilirsiniz. Hızlı hata ayıklama için bu basit koda bir cevap değiştirdim

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

Kayıtlı bir kapatma işlevinin içine şöyle bir istisna atamazsınız:

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

Ancak isteği yakalayabilir ve başka bir sayfaya yönlendirebilirsiniz.

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

PHP> = 5.1.0 kullanıyorsanız, ErrorException sınıfıyla böyle bir şey yapın:

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

Zend Framework 2'de hoş bir çözüm bulundu:

/**
 * 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);
    }
}

Bu sınıf, ErrorHandlerihtiyaç duyduğunuzda belirli dersleri bazen başlatmanızı sağlar . Ve sonra İşleyiciyi de durdurabilirsiniz.

Bu sınıfı örneğin şu şekilde kullanın:

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;

Tam sınıf koduna bağlantı:
https://github.com/zendframework/zf2/blob/master/library/Zend/Stdlib/ErrorHandler.php

Belki daha iyi bir çözüm, Monolog'dan bir çözümdür :

Ayrıca register_shutdown_functionişlevi kullanarak FATAL_ERRORS ile başa çıkabilir . Bu sınıfa göre FATAL_ERROR aşağıdakilerden biridir 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;
    }

    // [...]
}

Bunun yerine üretim için statik hataları 503 Hizmet Kullanılamaz HTML çıktısı göstermek için ölümcül hataları ele gerekir . Bu kesinlikle "ölümcül hataları yakalamak" için makul bir yaklaşımdır. Ben de bunu yaptım:

Herhangi bir E_ERROR, E_USER_ERROR, vb. Üzerinde "503 hizmet kullanılamıyor" HTML sayfamı görüntüleyecek özel bir hata işleme fonksiyonu "error_handler" var.

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

benim özel error_handler fonksiyonu, eğer hata E_ERROR, E_USER_ERROR, vb. Ben de @ob_end_clean();tampon boşaltmak için çağrı , böylece PHP'nin "ölümcül hata" mesajını kaldırıyorum.

@Error_handler komut dosyalarımızın herhangi bir hata oluşturmasını istemediğimiz için katı isset () kontrol ve susturma fonksiyonlarını dikkate alın .

Hala keparo ile hemfikir olmakla birlikte, ölümcül hataları yakalamak "FATAL hatasının" amacını bozar, bu nedenle daha fazla işlem yapmanız amaçlanmamıştır. Kesinlikle posta sunucusunu veya gelen kutunuzu yedekleyeceğiniz için bu kapatma işleminde posta () işlevlerini çalıştırmayın. Bunun yerine, bu error.log dosyalarını bulmak ve yöneticilere postalamak için bir cron işi zamanlamak için bu olayları günlüğe kaydedin .

PHP'nin önemli ölümcül hataları var. Bunlar E_RECOVERABLE_ERROR olarak tanımlanır. PHP el kitabı bir E_RECOVERABLE_ERROR'u şöyle tanımlar:

Yakalanabilir ölümcül hata. Muhtemelen tehlikeli bir hatanın meydana geldiğini, ancak Motoru kararsız bir durumda bırakmadığını gösterir. Hata, kullanıcı tanımlı bir tanıtıcı tarafından yakalanmazsa (ayrıca bkz. Set_error_handler () ), uygulama bir E_ERROR olduğu gibi iptal edilir.

Set_error_handler () öğesini kullanarak ve E_RECOVERABLE_ERROR öğesini kontrol ederek bu "ölümcül" hataları "yakalayabilirsiniz" . Bu hata yakalandığında bir İstisna atmak yararlı buluyorum, o zaman try / catch kullanabilirsiniz.

Bu soru ve cevap yararlı bir örnek sağlar: PHP türü ipucunda nasıl "yakalanabilir bir ölümcül hata" yakalayabilirim?

Bununla birlikte, E_ERROR hataları işlenebilir, ancak motor kararsız durumda olduğu için kurtarılamaz.

İşte geçerli error_handler yöntemini almak için güzel bir hile =)

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

Ayrıca şunu da belirtmek isterim ki

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

PHP hatayı görüntülemeyi durdurur. Aksi takdirde, hata metni hata işleyicinizden önce istemciye gönderilir.

Buradaki cevapların çoğu gereksiz yere ayrıntılı olduğundan, işte en çok oy alan cevabın çirkin olmayan versiyonum:

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

Pek sayılmaz. Ölümcül hatalar denir, çünkü ölümcüldürler. Onlardan kurtulamazsın.

Ben ölümcül hataya neden olabilir kod "sandbox" mümkün kılmak için bu işlevi geliştirdi. Kapatmadan atılan istisnalar, register_shutdown_functionölümcül hata çağrısı yığınından yayılmadığından, tekdüze bir kullanım yöntemi sağlamak için bu işlevden sonra çıkmak zorunda kaldım.

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

Ölümcül hataların bile yakalanması gereken bazı durumlar vardır (zarif bir şekilde çıkmadan önce biraz temizlik yapmanız gerekebilir ve sadece ölmeyin ..).

CodeIgniter uygulamalarımda bir pre_system kancası uyguladım, böylece e-postalarla ölümcül hatalarımı alabildim ve bu bana bildirilmedi (veya onlar zaten bildiği gibi, düzeltildikten sonra bildirildi) hataları bulmama yardımcı oldu :).

Sendemail, hatanın önceden bildirilip bildirilmediğini kontrol eder, böylece bilinen hatalarla size birkaç kez spam göndermez.

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