Système de log

Par défaut (en mode développement)

Le système de log de Sydonie est configuré par défaut pour produire 2 fichiers à la racine du site :

• log_core.log qui affiche les logs du coeur de Sydonie ;
• log_root.log qui affiche les logs du projet

Ces fichiers sont créés en mode DEBUG uniquement.

Pour tracer des informations dans ces fichiers, il suffit depuis un fichier du projet de passer par la classe Sydonie_Logger_Provider, il s'agit d'une factory qui crée des logs à volonté. Par défaut elle propose 2 accesseurs : getRootLogger() qui permettra de tracer les log du projet, et getCoreLogger() dédié ) tracer l’activité dans le coeur de Sydonie.

 // Affiche une alert
 Sydonie_Logger_Provider::getRootLogger()->alert("Aïe, on a repéré mon compte en suisse !");
 
 // Ou une information
 Sydonie_Logger_Provider::getRootLogger()->info("Je nie en bloc !");

La méthode getRootLogger() retourne un objet Sydonie_Logger_ILogger. Les logs par défaut de Sydonie sont configurés pour écrire les logs dans le fichier log_root.log

Utiliser plusieurs fichiers de logs

Il est possible de répartir les logs dans plusieurs fichiers, pour cela il suffit d'utiliser la méthode getLogger( $nomLog )

Sydonie_Logger_Provider::getLogger("transactions")->debug("Enregistrement sauvé");

Dans cet exemple, un fichier log_transactions.log sera créé à la racine du projet.

Accès simplifié

Une bonne pratique pour simplifier l'accès aux différents loggers consiste à créer une classe dans son projet qui va servir de point d'accès aux loggers :

 // fichier /monsite/config/site/config_site.php
 class MySiteLogger {
    public static function getTransactionsLogger(){
        return Sydonie_Logger_Provider::getLogger("transactions");
    }
 }

Modifier l'emplacement d'un fichier de log

Il suffit pour cela de forcer la création du loggeur en utilisant la classe Sydonie_Logger_StrSimple :

 // fichier /monsite/config/site/config_site.php
 class MySiteLogger {
    private static $transactions;
    public static function getTransactionsLogger() {
        if (null === self::$transactions) {
            self::$transactions = Sydonie_Logger_Provider::createLogger(
                            "transactions", new Sydonie_Logger_StrSimple("transactions", "logs/transactions.log")
            );
        }
        return self::$transactions;
    }
 }

Rendre certains log silencieux (Sans création de fichier)

La aussi, tout passe par la méthode Sydonie_Logger_Provider::createLogger(...). Sydonie propose une classe spéciale pour gérer les logs silencieux : Sydonie_Logger_Void

Par exemple, pour "couper" les logs d'un logger, il suffit de redéfinir le logger correspondant :

// fichier /monsite/config/site/config_site.php
 
// 'Coucou' s'affiche dans le fichier /monsite/log_root.log
Sydonie_Logger_Provider::getRootLogger()->info("Coucou");
 
// On redéfinit le logger pour 'root'
Sydonie_Logger_Provider::createLogger("root", new Sydonie_Logger_Void());
 
// Rien ne s'affiche dans le fichier
Sydonie_Logger_Provider::getRootLogger()->info("Ne s'affiche pas");

Exemple de loggeur utilitaires pour un projet

class MySiteLogger {
 
    private static $activated = false;
    private static $loggers = array();
    private static $void;
 
    /**
     * 
     * @param string $loggerName (Unique) Name of the logger
     * @return Sydonie_Logger_ILogger
     */
    private static function getLogger($loggerName) {
        if (!self::$activated) {
            return self::getVoidLogger();
        }
        if (!isset(self::$loggers[$loggerName])) {
            self::$loggers[$loggerName] = Sydonie_Logger_Provider::createLogger(
                            $loggerName, new Sydonie_Logger_StrSimple($loggerName, "logs/$loggerName.log")
            );
        }
        return self::$loggers[$loggerName];
    }
 
    /**
     * Returne the void logeur
     * 
     * @return Sydonie_Logger_ILogger
     */
    private static function getVoidLogger() {
        if (null === self::$void) {
            self::$void = new Sydonie_Logger_Void();
        }
        return self::$void;
    }
 
    /**
     * Direct access logger (no mistake with logger name)..
     * 
     * @return type
     */
    public static function getTransactionsLogger() {
        return self::getLogger('transactions');
    }
 
    // etc...
    public static function getPompilupLogger() {
        return self::getLogger('pompilup');
    }
 
}

Système de log avancés

Le système de log de Sydonie proposé nativement est suffisant dans la majorité des cas. Cependant certains projets nécessitent une gestion beaucoup plus fine du système de log. Ces fonctionnalités sont déjà disponibles dans des classes tel que log4php (apache) ou le célébre Monolog.

Dans Sydonie, le log provider (Sydonie_Logger_Provider) est construit pour distribuer des classes qui implémentent la méthode Sydonie_Logger_ILogger.

Pour intégrer l'une des librairies citées précédement, il suffit d'ajouter une classe adapteur à votre projet qui implémente Sydonie_Logger_ILogger et qui fera la jonction entre le système de log de Sydonie et la librairie utilisée.

// Exemple avec Monolog
use Monolog\Logger;
use Monolog\Handler\StreamHandler;
class MyLogger implements Sydonie_Logger_ILogger {
    private $log;
    function __construct( $name ) {
        $this->log = new Logger($name);
        $this->log->pushHandler(new StreamHandler("logs/$name.log", Logger::DEBUG));
    }
 
    public function alert($message, array $context = array()) {
        $this->log->alert($message, $context);
    }
 
    public function crit($message, array $context = array()) {
        $this->log->crit($message, $context);
    }
 
    public function debug($message, array $context = array()) {
        $this->log->debug($message, $context);
    }
 
    public function emerg($message, array $context = array()) {
        $this->log->emerg($message, $context);
    }
 
    public function err($message, array $context = array()) {
        $this->log->err($message, $context);
    }
 
    public function info($message, array $context = array()) {
        $this->log->info($message, $context);
    }
 
    public function notice($message, array $context = array()) {
        $this->log->notice($message, $context);
    }
 
    public function warn($message, array $context = array()) {
        $this->log->warn($message, $context);
    }
}
 
// On modifie le logger "root" pour utiliser monolog
Sydonie_Logger_Provider::createLogger('root', new MyLogger('root'));