Trace des erreurs en php

Commenter

Contenu du snippet

Bonjour,
Ci-joint un exemple permettant de voir un trace des fonctions qui ont abouti à une erreur. Le trace est écrit dans le fichier "Trace.log" du répertoire courrant.
Cet exemple est opérationnel avec php5. Pour le rendre opérationnel avec php4, il est nécessaire de modifier les balise /*#V5*/ par /*#V5__ et /*#V4__ par /*#V4*/.
La class Obj_Trace est la classe qui gère l'écriture des fonctions appelées ainsi que les valeurs des différents paramètres.
La class Obj_GetObject permet d'accéder à toutes les attributs private ou protected des class dérivées de Obj_GetObject.
En fin de script, un exemple permet de tester ce script (division par zéro)

Source / Exemple : 


<?php
 // TestError.php
//                            "/*#V5__",   0 //debut commentaire  si (V4)
//	                           "/*#V5*/",   1 //debut instruction  si (V5)
//                            "/*#V4*/",   2 //fin   commentaire  si (V4)
//                            "/*#V4__",   3 //debut commentaire  si (V5)
//                            "/*#V*/",    4 //fin instruction et fin commentaire   si (V4) ou (V5)
// POUR PASSER EN VERSION 5 (plus utile que réaliser un programme qui génère du code
//                           en fonction des #IFDEF et autres
//
//si version 5 le constructeur doit etre __construct($Name1,$Value1)
//             le destructeur doit etre __destruct()
//             le constructeur et le destructeur V4 sont acceptés
//              les variables sont soit 'var', 'private', 'protected'
//              si "private"   les variables ne sont accessibles que dans la classe
//              si "protected" les variables sont accessibles par les classes dérivées
//              si "var"    les variables sont toujours accessibles
//si version 4 le constructeur  doit avoir le meme nom que la class ex: NameClass()
//             le destructeur doit avoir le meme nom que la class précédéavec '_' ex: _NameClass()
//             les variables sont toutes 'var'
// DefError_V#     # est soit 4 ou 5
//SI !isset($_SERVER['SERVER_NAME']) || $_SERVER['SERVER_NAME'] === 'localhost' => Le script est lancé avec PHPEdit
 //DANS CE CAS LA DIRECTIVE 'include_path' contient les path des fichiers
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class Obj_Trace
{
 /*#V5*/  static private /*#V4__  var /*#V*/ $TraceNameFile = "Trace.log";
 /*#V5*/  static public  /*#V4__  var /*#V*/ $TraceHandle = 0;
 /*#V5*/  static public  /*#V4__  var /*#V*/ $TraceStatus = TRUE;
 //---------------------------------------------------------------------------
 /*#V5*/ static /*#V*/ function OpenFileTrace()
 {  /*#V5*/ self::$TraceHandle /*#V4__ $this->TraceHandle /*#V*/ =
                     fopen(/*#V5*/ self::$TraceNameFile /*#V4__ $this->TraceFullNameFile /*#V*/ ,"at");
    if (! /*#V5*/ self::$TraceHandle /*#V4__ $this->TraceHandle /*#V*/)
    {  /*#V5*/ self::$TraceStatus /*#V4__ $this->TraceStatus /*#V*/ = FALSE;
       trigger_error("File '"./*#V5*/ self::$TraceNameFile /*#V4__ $this->TraceFullNameFile /*#V*/.
                      "' ne peut être ouvert en mode append!", _FATAL_ERROR_);
    }
 }
 //---------------------------------------------------------------------------
 /*#V5*/ static /*#V*/ function CloseFileTrace()
 {  if (/*#V5*/ self::$TraceStatus /*#V4__ $this->TraceStatus /*#V*/ === TRUE)
       fclose(/*#V5*/ self::$TraceHandle /*#V4__ $this->TraceHandle /*#V*/);
 }
 //---------------------------------------------------------------------------
 /*#V5*/ static /*#V*/ function WriteLineTrace($Line)
 {  if (/*#V5*/ self::$TraceStatus /*#V4__ $this->TraceStatus /*#V*/ === TRUE)
    {  if (($Size = fwrite (/*#V5*/ self::$TraceHandle /*#V4__ $this->TraceHandle /*#V*/ , $Line, strlen($Line))) <= 0)
       {  /*#V5*/ self::$TraceStatus /*#V4__ $this->TraceStatus /*#V*/ = FALSE;
          trigger_error("'"./*#V5*/ self::$TraceNameFile /*#V4__ $this->TraceFullNameFile /*#V*/.
                      "' ne peut être écrit!", _FATAL_ERROR_);
       }
    }
 }
 //---------------------------------------------------------------------------
 /*#V5*/ static /*#V*/ function GetVar($Line, $Var, $bFirst = FALSE)
 {   switch (gettype($Var))
     {
     case 'integer':
     case 'double':
          return $Var;
     case 'string':
          return '"'.str_replace( array("\x00", "\x0a", "\x0d", "\x1a", "\x09"),
                       array('\0', '\n', '\r', '\Z', '\t'), $Var ).'"';
     case 'array':
          $VarNew = $Var;
     case 'object':
          if ($bFirst === TRUE)
          {  $LineCurrent = (gettype($Var) === 'object') ?
                 $Line."object '".get_class($Var)."' [" : $Line."array (";
             /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $LineCurrent);
          }
          if (gettype($Var) === 'object')
          {  // TEST SI OBJECT CONTIENT LA METHODE 'MyGetArray' qui permet
             // l'accès aux variables private, protected et public avec leurs noms
             // SOIT   if (is_callable(array($Var,"MyGetArray")))
             //  bool  is_callable ( mixed   var , bool   syntax_only , string   callable_name )
             //  is_callable vérifie qu'une variable peut être appelée comme fonction.
             //  Cette fonction peut vérifier qu'une variable contient un nom de fonction valide,
             //  ou bien qu'elle contient un tableau, avec un objet et un nom de méthode.

             // SOIT   if (in_array("MyGetArray",get_class_methods($Var)))
             //  array get_class_methods(string class_name )
             //  get_class_methods retourne un tableau contenant les noms des méthodes de la classe class_name.
             // ON ESSAYE LES DEUX CAR get_class_methods peut etre infructueux
             if (in_array("MyGetArray",get_class_methods($Var)))
             {  $VarNew = $Var->MyGetArray(); }
             else
             {  if (is_callable(array($Var,"MyGetArray")))
                {  $VarNew = $Var->MyGetArray();  }
                else
                {  //NE RETOURNE QUE LES ATTRIBUTS 'PUBLIC'
                   $VarNew = get_object_vars($Var);
                }
             }
          }
          $Line = $Line. "    ";
          foreach($VarNew as $Key => $Val)
          {  $LineCurrent = $Line;
             $LineCurrent .= /*#V5*/ self::GetVar( /*#V4__ $this->GetVar( /*#V*/ $Line, $Key)." => ";
             if (!is_object($Val) && !is_array($Val))
             {  $LineCurrent .= /*#V5*/ self::GetVar( /*#V4__ $this->GetVar( /*#V*/  $Line, $Val);
                /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/  $LineCurrent);
             }
             else
             {
                $LineCurrent .= (is_array($Val))? "array (" : "object '".get_class($Val)."' [";
                /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/  $LineCurrent);
                /*#V5*/ self::GetVar( /*#V4__ $this->GetVar( /*#V*/  $Line, $Val);
             }
          }
          if (is_array($Var) || is_object($Var))
          {  $LineCurrent = (is_array($Var)) ? " )" : " ]";
             /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/  $LineCurrent);
          }
          return;
     case 'resource':
          return "Resource(".strstr($Var, "#").")";
     case 'boolean':
          return $Var ? "True" : "False";
     case 'NULL':
          return "null";
     default:
          return "Unknown";
     }
 }
 //---------------------------------------------------------------------------
 /* PROBLEME AVEC PHPEDIT bug
   + function: unknown (  )
   ++'dbg_eval()' => line : 1
   ++ function: MonitoringError (
   ++            8
   ++            "Undefined variable: this"
   ++            "dbg_eval()"
   ++            1
   ++            array (


     
  • /

 /*#V5*/ static /*#V*/ function WriteTrace($BackTrace, $NumError, $StringError, $Script, $Ligne)
 {
    $bBugError = FALSE;
    /*#V5*/ self::OpenFileTrace( /*#V4__ $this->OpenFileTrace( /*#V*/ );
    if (isset($_SERVER['SERVER_NAME']) && $_SERVER['SERVER_NAME'] !== 'localhost')
    {  $Line = "\n\n".Date("d/m/Y H:i:s");
       /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
    }
    $Line ="";
    for ( $bBugError = FALSE, $Space = "", $i = count($BackTrace) - 1; $i >= 0 && $bBugError === FALSE ; $i--)
    {  $Space .= "+";
       $Line = "\n".$Space;
       $LineMatrice = $Line;
       if (isset($BackTrace[$i]["file"]))
          $Line .= "'".$BackTrace[$i]["file"]."'";
       if (isset($BackTrace[$i]["line"]))
          $Line .= " => line : ".$BackTrace[$i]["line"];
       if ($Line != $LineMatrice)
       {  if (strtolower($BackTrace[$i]["file"]) === "dbg_eval()" && $BackTrace[$i]["line"] === 1)
          {  $bBugError = TRUE;
             $Line .= " [bug avec PhpEdit1-8]";
          }
          /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
          if ($bBugError === TRUE)
             continue;
       }
       $Function ="";
       if (isset($BackTrace[$i]["function"]))
       {  $Function = $BackTrace[$i]["function"];
          if ( $Function == 'include' || $Function == 'require' ||
               $Function == 'include_once' || $Function == 'require_once' )
             $Function = "";
       }
       if ($Function === "")
          continue;
       if (strtolower($Function) === "monitoringerror")
          break;
       $Line = $LineMatrice;
       $Line .= " function: ".$Function ." ( ";
       /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
       if(isset( $BackTrace[$i]['args'][0]))
       {  $Virgule = " ";
          foreach( $BackTrace[$i]['args'] as $Arg )
          {  if (empty($Arg) && $Arg !== 0)
                continue;
             $Line = $LineMatrice."           ";
             $Line .= $Virgule./*#V5*/ self::GetVar( /*#V4__ $this->GetVar( /*#V*/ $Line, $Arg, TRUE);
             $Virgule = ",";
             /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
          }
       }
       $Line = $LineMatrice."           ".")";
       /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);
    }
    $Line = "\n Error: ".$NumError." '".$StringError."' on script '".$Script."' line :".$Ligne;
    /*#V5*/ self::WriteLineTrace( /*#V4__ $this->WriteLineTrace( /*#V*/ $Line);    
    /*#V5*/ self::CloseFileTrace( /*#V4__ $this->CloseFileTrace( /*#V*/ );
    return $bBugError;
 }
 //---------------------------------------------------------------------------
}
//--------------------------------------------------------------------------------------------
//TRAITEMENT DES ERREURS
  define ("_FATAL_ERROR_",   E_USER_ERROR);
  define ("_WARNING_ERROR_", E_USER_WARNING);
  define ("_ALERT_ERROR_",   E_USER_NOTICE);

 // Creation objet ExObj_Trace en place de la class static Obj_Trace pour compatibilite avec php 4
 /*#V4__ $ExObj_Trace = new Obj_Trace; /*#V*/
  error_reporting (_FATAL_ERROR_ | _WARNING_ERROR_ | _ALERT_ERROR_);
  $ErrorMonitoring = set_error_handler("MonitoringError");
/*
 ini_set ('track_errors', TRUE);
 ini_set ( "display_errors","off");
 ini_set ( "log_errors","on");
 ini_set ( "log_error_max_len","1024");
 ini_set ( "track_errors","off");
 ini_set ( "error_log","./log/php-error.log");


  • /

//--------------------------------------------------------------------------------------------
 function MonitoringError($NumError, $MsgError, $Script, $Line)
 {
    $StringError =  "<u>Numéro :</u> ".$NumError."<u> Message :</u> ".$MsgError
                 . "<br><u>Fichier :</u> ".$Script."<u> line :</u> ". $Line;

    $BackTrace = debug_backtrace();
    if ( /*#V5*/ Obj_Trace::$TraceStatus /*#V4__ $GLOBALS["ExObj_Trace"]->TraceStatus /*#V*/ === TRUE)
    {  $bBugError = /*#V5*/ Obj_Trace::WriteTrace( /*#V4__ $GLOBALS["ExObj_Trace"]->WriteTrace( /*#V*/
             $BackTrace, $NumError, $MsgError, $Script, $Line);
       if ($bBugError === TRUE)
          return;
    }
    switch ($NumError)
    {
       case _FATAL_ERROR_:
         echo "<h3 style='color:#FF0000'>Erreur <i>E_USER_ERROR</i> :</h3>".$StringError;
         exit -1;
         break;

       case _WARNING_ERROR_:
         echo "<h3 style='color:#FF0000'>Erreur <i>E_USER_WARNING</i> :</h3>".$StringError;
         break;

       case _ALERT_ERROR_:
         echo "<br> Erreur <i>E_USER_NOTICE</i>  :".$StringError;
         break;

       default:
         echo "<h3 style='color:#FF0000'>Erreur inconnue :</h3>".$StringError;
         break;
    }
 }
//--------------------------------------------------------------------------------------------
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Cette class permet de voir tous les attributs de la classe (private, protected et public
class Obj_GetObject
{
 /*#V5*/ public    /*#V4__ var /*#V*/ $bGetObject;

  //Constructeur necessaire sinon peut provoquer une erreur
   function /*#V5*/   __construct( /*#V4__ Obj_GetObject( /*#V*/ )
   {  $this->bGetObject = TRUE;    }

   //permet de voir meme les private et les protected
   /*#V5*/  public /*#V*/ function MyGetArray()
   {
      return get_object_vars($this);
   }

}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class TestErreur extends Obj_GetObject
{
   private $a1;
   private $a2;
   private $a3;

   function /*#V5*/   __construct( /*#V4__ Obj_GetObject( /*#V*/ )
   {  // -----  APPEL CONSTRUCTEUR Obj_GetObject -----
      /*#V5*/ parent::__construct( /*#V4__ parent::Obj_GetObject( /*#V*/);
      $this->a1 = 200;
      $this->a2 = 300;
      $this->a3 = array ("un"=> 1, "deux"=>2);
   }
   /*#V5*/  private /*#V*/function Un($var)
   {  $this->a1/=$var;
   }
   /*#V5*/  private /*#V*/function Deux($var)
   {  $this->a1+=$var;
      $this->Un($var);
   }
   /*#V5*/  public /*#V*/function Trois($var)
   {  $this->Deux($var);
   }
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
function Calcul($V,$W)
{
   $V->Trois($W);
}

//test
$Obj = new TestErreur;
Calcul($Obj,0);
?>

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Laurpierre)