MVC-Framework – Der neue Debugger ist fertig

Vor einigen Wochen habe ich über den aktuellen Stand des Frameworks berichtet. Ich habe in diesem Artikel auch geschrieben, dass ich mit dem Debugger überhaupt nicht zufrieden bin. Auf meiner TODO-Liste stand deshalb ganz oben:

FW_Debugger neu schreiben

Das habe ich dann auch getan!

Er ist jetzt viel dynamischer als vorher. Man kann die verschiedenen Debugging-Arten ganz einfach selbst erweitern und entscheiden, was wie geloggt wird. Hier ein Beispiel:

$d = FW_Debugger::getInstance();
$d->addDebugger("file_errors", new FW_Debugger_File("../logs/errors.log", array(E_ERROR, E_USER_ERROR)));
$d->addDebugger("file_warnings", new FW_Debugger_File("../logs/warnings.log", array(E_WARNING, E_USER_WARNING)));
$d->addDebugger("file_notices", new FW_Debugger_File("../logs/notices.log", array(E_NOTICE, E_USER_NOTICE)));
$d->addDebugger("file_others", new FW_Debugger_File("../logs/others.log", array(E_STRICT, E_RECOVERABLE_ERROR, E_PARSE)));
$d->addDebugger("bildschirm", new FW_Debugger_Screen(array(E_ALL)));

Man kann wie man sieht mehrere Objekte des gleichen Typs unter unterschiedlichen Namen einfügen. So kann man (wie ich es getan habe) eigene Dateien für bestimmte Fehlertypen festlegen.

FW_Debugger
FW_Debugger ist eine Singleton-Klasse, die alle Debuggerinstanzen beinhaltet. Man kann mit addDebugger(„NAME“, Objekt) einen neuen Debugger hinzufügen. Es gibt standartmäßig 2 verschiedene Debugger im Framework: FW_Debugger_File (Logging in Datei), FW_Debugger_Screen (Ausgabe auf dem Bildschirm, nur sinnvoll in der Entwicklung). Wer mehr will, kann einen eigenen programmieren. Dieser muss nur das FW_Debugger_Interface implementieren. Z.B. könnte jemand Fehler in einer Datenbank loggen wollen. Hier muss man aber aufpassen: Wenn hier ein Fehler auftritt, bekommt der Admin nichts davon mit!

Und hier der komplette Code von FW_Debugger:

< ?php
/**
 * @licence See: /licence.txt
 */ 

/**
 * SINGLETON
 * Debugger-Klasse für das Framework
 * @author Simon H.
 * @version 2
 * @package MVC-Framework
 * 
 * Diese Klasse ist dazu da, das Projekt zu debuggen.
 * 
 * Die Klasse bietet eine statische Methode zum registrieren des Errorhandlers von PHP.         
 */
class FW_Debugger implements FW_Debugger_Interface
{
  /**
   * @access protected
   * @var object instance
   * Speichert die Instanz der Klasse        
   */  
  protected static $instance = null;

  /**
   * @access protected
   * @var array debuggers
   * 
   * Speichert alle Debuggerobjekte         
   */     
  protected $debuggers = array();

  /**
   * Für Singleton
   */     
  private function __clone() {}

  /**
   * @return object
   * @access public
   * getInstance gibt eine Instanz zurück und sorgt dafür, dass es nur eine gibt.
   * (Singleton)           
   */  
  public static function getInstance()
  {
    if(self::$instance === null)
    {
      self::$instance = new FW_Debugger();
    }
    return self::$instance;
  }

  /**
   * @access private
   * Der Konstruktor initialisiert die Einstellungen   
   */     
  private function __construct() 
  {
  }

  /**
   * @access public
   * @param string                $name
   * @param FW_Debugger_Interface $debugger  
   * 
   * Fügt einen Debugger zur Debuggerliste hinzu.          
   */     
  public function addDebugger($name, FW_Debugger_Interface $debugger)
  {
    $this->debuggers[$name] = $debugger;
  }

  /**
   * @access public
   * @param string  $message
   * @param string  $file
   * @param integer $line
   * @param mixed   $type
   * 
   * Loggt $message mit jedem Debugger, der über addDebugger hinzugefügt wurde
   * Übergabe von "error", "notice", "warning" als 4. Parameter vereinfacht
   * die Nutzung des Debuggers als User                       
   */     
  public function log($message, $file, $line, $type)
  {
   if($type == "error")
   {
     $type = E_USER_ERROR;
   }

   if($type == "notice")
   {
     $type = E_USER_NOTICE;
   }

   if($type == "warning")
   {
     $type = E_USER_WARNING;

   }

    foreach($this->debuggers as $debugger)
    {
      $debugger->log($message, $file, $line, $type);
    }
  }

  /**
   * @access public 
   * Registriert die statische methode handleError als error_handler                  
   */
  public static function registerErrorHandler()
  {
    set_error_handler(array("FW_Debugger", "handleError"));
  }

  /**
   * @access public 
   * @param int errno
   * @param string errstr
   * @param string errfile
   * @param int errline
   * @param mixed context               
   * Behandelt Fehler, die über den error_handler kommen                 
   */
  public static function handleError($errno, $errstr = '', $errfile = '', $errline = '', $context = null)
  {
    $debugger = FW_Debugger::getInstance();
    $debugger->log("Errorhandler: ".$errstr, $errfile, $errline, $errno);
  }

  /**
   * @access public static
   * @param  integer $errno
   * @return string
   * 
   * Wandelt eine Fehlernummer in einen String um.            
   */     
  public static function Errno2String($errno)
  {
    switch($errno)
    {
      case E_ERROR:               return "E_ERROR";
      case E_WARNING:             return "E_WARNING";
      case E_PARSE:               return "E_PARSE";
      case E_NOTICE:              return "E_NOTICE";    
      case E_CORE_ERROR:          return "E_CORE_ERROR";
      case E_CORE_WARNING:        return "E_CORE_WARNING";
      case E_COMPILE_ERROR:       return "E_COMPILE_ERROR";
      case E_COMPILE_WARNING:     return "E_COMPILE_WARNING";
      case E_USER_ERROR:          return "E_USER_ERROR";
      case E_USER_WARNING:        return "E_USER_WARNING";
      case E_USER_NOTICE:         return "E_USER_NOTICE";
      case E_ALL:                 return "E_ALL";
      case E_STRICT:              return "E_STRICT";
      case E_RECOVERABLE_ERROR:   return "E_RECOVERABLE_ERROR";
      //NUR PHP6
      //case E_DEPRECATED:          return "E_DEPRECATED";
      //case E_USER_DEPRECATED:     return "E_USER_DEPRECATED";
      default:                    return "UNKNOWN";
    }
  }
}
?>

FW_Debugger_Interface

< ?php
interface FW_Debugger_Interface
{
  public function log($message, $file, $line, $type);
}
?>

Das ist das Interface, das von allen Debuggern implementiert werden muss. Ansonsten werden sie von FW_Debugger::addDebugger nicht angenommen (Type Hints machens möglich :))

Der Parameter $type enthält den Fehlertyp (E_Error, E_Notice, …) .

FW_Debugger_Screen

< ?php
class FW_Debugger_Screen implements FW_Debugger_Interface
{
  protected $types = array();

  public function __construct(array $types = array())
  {
    $this->types = $types;
  }

  public function log($message, $file, $line, $type)
  {
    if(in_array($type, $this->types) || 
       count($this->types) == 0 ||
       in_array(E_ALL, $this->types)
      )
    {
      echo "Es ist ein Fehler aufgetreten: \n".
           "Zeile ".$line." \n".
           "Datei ".$file." \n".
           "Typ ".FW_Debugger::Errno2String($type)."(".$type."): ".$message.
           " \n\n";
    }
  }
}
?>

FW_Debugger_File

< ?php
class FW_Debugger_File implements FW_Debugger_Interface
{
  protected $destination = "";
  protected $types = array();

  public function __construct($destination, array $types = array())
  {
    if(empty($destination))
    {
      throw new FW_Debugger_Exception("Bitte ein Ziel für den Debugger angeben");
    }
    $this->destination = $destination;
    $this->types = $types;
  }

  public function log($message, $file, $line, $type)
  {
    if(in_array($type, $this->types) || 
       count($this->types) == 0 ||
       in_array(E_ALL, $this->types)
      )
    {
      $string = FW_Debugger::Errno2String($type)."(".$type.") | ".$_SERVER["REMOTE_ADDR"];
      $string .= " | ".date("d.m.Y - H:i:s", time())." | Datei: ".$file." | Zeile: ".$line;
      $string .= " | \n-->".$message;  
      FW_Tools::addStringToFile($this->destination, $string, "\n", "\n");
    }
  }
}
?>

Eure Meinung
Wie findet ihr das Konzept?

1 Star2 Stars3 Stars4 Stars5 Stars (Wurde noch nicht bewertet)
Loading...


2 Kommentare zu “MVC-Framework – Der neue Debugger ist fertig”

  1. […] habe euch vor ein paar Tagen von meinem FW_Debugger berichtet. Dieser Debugger war indirekt an meiner stundenlangen Fehlersuche schuld. Den […]

  2. Die aktuellste Version meines HMVC-Frameworks erhaltet ihr ab sofort immer hier: http://www.net-developers.de/blog/2011/02/13/download-info-shfw-hmvc-framework-in-php/

Hinterlasse einen Kommentar!

Time limit is exhausted. Please reload the CAPTCHA.

»Informationen zum Artikel

Autor: Simon
Datum: 03.01.2009
Zeit: 20:56 Uhr
Kategorien: Mein MVC-Framework
Gelesen: 3240x heute: 5x

Kommentare: RSS 2.0.
Diesen Artikel kommentieren oder einen Trackback senden.

»Meta