Implémenter la gestion des erreurs dans mon cadre

Question

Je suis sur le point de commencer à mettre en œuvre la gestion des erreurs dans mon cadre de travail et je cherche quelques conseils sur la façon de le construire.

Tout d'abord, permettez-moi d'expliquer comment mon cadre est actuellement construit :

Je sépare le démarrage du framework du démarrage de l'application, donc toute erreur causée par le démarrage de l'application doit être gérée spécifiquement par une classe dédiée à cela.

Mon idée est d'avoir une classe appelée Core_Error_exception Ce qui va régler le rapport d'erreur sur E_ALL car mon cadre sera strict sur les erreurs pour PHP 5.3 Ensuite, dès que mon application sera chargée, j'exécuterai une fonction d'arrêt dans cette classe pour rétablir toutes les valeurs par défaut modifiées.

Ce que je cherche à faire est de capturer toutes les erreurs qui sont E_*_NOTICE et non E_*_ERROR puis, avant le démarrage de l'application, j'indique à la classe d'arrêter de capturer les erreurs, car la classe Application_Error_Exception seront à l'affût des erreurs.

J'ai donc besoin d'un moyen de suivre toutes les erreurs, y compris les exceptions et les déclencheurs, puis d'afficher une page de débogage avant l'initialisation de l'application.

Le type de classe que je recherchais est le suivant :

class Core_Error_Exception
{
    var $previus_error_level,$captured_contents;

    private $stack_trace = array();

    public function Core_Error_Exception()
    {
        $this->previus_error_level = error_reporting(-1);
        set_error_handler(array($this,'_collect_error'));
        set_exception_handler(array($this,'_collect_error'));
        ob_start(array($this,'_capture'));
    }

    public function _collect_error($errno, $errstr, $errfile, $errline, $context)
    {
        $this->stack_trace[] = array(
            array('name' => 'Error ID:',    'value' => $errno),
            array('name' => 'Error String:','value' => $errstr),
            array('name' => 'Error File:',  'value' => $errfile),
            array('name' => 'Error Line:',  'value' => $errline),
            array('name' => 'Context PRE:', 'value' => $context)
        );
        var_dump($this->stack_trace);
    }

    /*
     * _capture is used to capture pre_bufferd content.
     */
    public function _capture($content,$bitfeild)
    {
        if($bitfeild & PHP_OUTPUT_HANDLER_START)
        {
            $this->captured_contents = $content;
        }

        if($bitfeild & PHP_OUTPUT_HANDLER_CONT)
        {
            $this->captured_contents .= $content;
        }

        if($bitfeild & PHP_OUTPUT_HANDLER_END)
        {
            $this->captured_contents .= $content;
        }
        return false;
    }
}

Donc, ce que je cherche à faire, c'est de pouvoir construire cette classe de manière à ce que toutes les erreurs de notification qui ont pu être déclenchées soient placées dans un tableau, si une notification E_ERROR est appelée, alors cela lance automatiquement l'arrêt à ce moment-là, pour éviter que d'autres erreurs soient causées.

J'utiliserai un petit gestionnaire de modèle html dans lequel je pourrai passer des ensembles d'erreurs dans ce contexte, de sorte que les erreurs de notification et un simple E_*_ERROR le cas échéant.

Quelle est la meilleure façon de construire cette classe ? Dans le passé, j'ai eu quelques difficultés à faire le suivi et le rapport des erreurs.

Mise à jour de : avec la classe actuelle

Si des erreurs sont déclenchées, par exemple trigger_error('test',XXX) ; je veux pouvoir suivre toutes les erreurs jusqu'à ce que l'application soit lancée ou qu'un E_USER_ERROR ait été déclenché.

Parfois, j'ai du mal à comprendre le système d'erreur de PHP, et ainsi de suite, car parfois je ne sais pas comment le construire pour qu'il soit à l'abri des erreurs.

Answer 1

Je ne suis pas tout à fait sûr de ce que vous faites, mais le moyen le plus simple serait d'utiliser des blocs d'essai imbriqués, selon le modèle suivant

in Class Application:

    function run() {
        try {
            --do stuff
        } catch(AppException $e) {
            -- handle application-level exception
        }
        -- all other exceptions fall through

in Class Core:

    try {
        $core->init();
        $application->run(); <-- calls the above function
        $core->done();
    } catch(Exception $e) {
        --last chance exception handler
        --process exceptions the Application was unable to handle on its own
    }

Pour être en mesure d'attraper les erreurs intégrées de php ou trigger_error événements de cette manière, vous devriez aussi toujours installer un gestionnaire d'erreurs à exceptions .

Answer 2

Ce que vous avez semble assez solide. Il faudrait ajouter une certaine logique pour que, lorsque l'erreur est lancée et qu'elle arrête votre script, vous vidiez la sortie dans le tampon ob et envoyiez toutes les données collectées à votre fichier HTML d'erreur pour afficher la trace. Quelque chose comme :

public function _collect_error($errno, $errstr, $errfile, $errline, $context)
{
    $this->stack_trace[] = array(
        array('name' => 'Error ID:',    'value' => $errno),
        array('name' => 'Error String:','value' => $errstr),
        array('name' => 'Error File:',  'value' => $errfile),
        array('name' => 'Error Line:',  'value' => $errline),
        array('name' => 'Context PRE:', 'value' => $context)
    );

    if($errno == E_USER_ERROR) {
        ob_clean();
        // Pass collected data to HTML template
        // Display HTML
        exit();
    }

    var_dump($this->stack_trace);
}

Je ne suis pas sûr à 100% que vous puissiez récupérer gracieusement d'une erreur fatale, mais d'après ce que vous dites, vous cherchez simplement des erreurs spécifiques non fatales pour arrêter le traitement.

Quelle est votre intention de capturer du contenu en mémoire tampon ? Je suppose qu'il est soit affiché si l'erreur que vous recherchez n'est jamais atteinte, soit rejeté et un écran d'erreur est affiché (c'est pourquoi j'ai ajouté ob_clean dans la fonction d'erreur) ?