Previous Next

Rédacteurs (Writers)

Un rédacteur est un objet qui hérite de Zend_Log_Writer_Abstract. La responsabilité d'un rédacteur est d'enregistrer des données de log dans un stockage particulier.

Écrire vers un flux (stream)

Zend_Log_Writer_Stream envoie des données de log à un » flux de PHP.

Pour écrire des données de log dans le buffer d'affichage de PHP, il faut utiliser l'URL php://output. Alternativement, vous pouvez préférer envoyer des données de log directement à un flux comme STDERR (php://stderr).

$redacteur = new Zend_Log_Writer_Stream('php://output');
$logger = new Zend_Log($redacteur);

$logger->info("Message d'information");

Pour écrire des données dans un fichier, employer un des » Filesystem URLs:

$redacteur = new Zend_Log_Writer_Stream('/chemin/vers/fichierdelog');
$logger = new Zend_Log($redacteur);

$logger->info("Message d'information");
Par défaut, le flux s'ouvre en mode d'ajout ("a"). Pour l'ouvrir avec un mode différent, le constructeur de Zend_Log_Writer_Stream accepte un deuxième paramètre facultatif pour le mode.

Le constructeur de Zend_Log_Writer_Stream accepte également une ressource existante de flux :

$flux = @fopen('/chemin/vers/fichierdelog', 'a', false);
if (! $flux) {
    throw new Exception('Impossible d\'ouvrir le flux');
}

$redacteur = new Zend_Log_Writer_Stream($flux);
$logger = new Zend_Log($redacteur);

$logger->info("Message d'information");
Vous ne pouvez pas indiquer le mode pour des ressources existantes de flux. Le faire entraînera une Zend_Log_Exception.

Écrire dans des bases de données

Zend_Log_Writer_Db écrit les informations de log dans une table de base de données en utilisant Zend_Db. Le constructeur de Zend_Log_Writer_Db reçoit une instance de Zend_Db_Adapter, un nom de table, et un plan de correspondance entre les colonnes de la base de données et les données élémentaires d'événement :

$parametres = array ('host'     => '127.0.0.1',
                 'username' => 'malory',
                 'password' => '******',
                 'dbname'   => 'camelot');
$db = Zend_Db::factory('PDO_MYSQL', $parametres);

$planDeCorrespondance = array('niveau' => 'priority', 'msg' => 'message');
$redacteur = new Zend_Log_Writer_Db($db,
                                    'nom_de_la_table_de_log',
                                    $planDeCorrespondance);

$logger = new Zend_Log($redacteur);

$logger->info("Message d'information");
L'exemple ci-dessus écrit une ligne unique de données de log dans la table appelée nom_de_la_table_de_log. La colonne de base de données appelée niveau reçoit le niveau de priorité et la colonne appelée msg reçoit le message de log.

Écrire vers Firebug

Zend_Log_Writer_Firebug envoie des données de journalisation vers la » console Firebug.

zend.wildfire.firebug.console.png

Toutes les données sont envoyées via le composant Zend_Wildfire_Channel_HttpHeaders qui utilise les entêtes HTTP pour s'assurer que le contenu de la page n'est pas perturbé. Déboguer les requêtes AJAX qui requière du JSON "propre" ou un réponse XML est possible avec cette approche.

Éléments requis :

Example #1 Journaliser avec Zend_Controller_Front

// Placez ceci dans votre fichier d'amorçage
// avant de dispatcher votre contrôleur frontal
$writer = new Zend_Log_Writer_Firebug();
$logger = new Zend_Log($writer);

// Utiliser ceci dans vos fichiers de modèles, vues et contrôleurs
$logger->log('Ceci est un message de log !', Zend_Log::INFO);

Example #2 Journaliser sans Zend_Controller_Front

$writer = new Zend_Log_Writer_Firebug();
$logger = new Zend_Log($writer);

$request = new Zend_Controller_Request_Http();
$response = new Zend_Controller_Response_Http();
$channel = Zend_Wildfire_Channel_HttpHeaders::getInstance();
$channel->setRequest($request);
$channel->setResponse($response);

// Démarrer l'output buffering
ob_start();

// Maintenant vous pouvez appeler le logguer
$logger->log('Ceci est un message de log !', Zend_Log::INFO);

// Envoi des données de journalisation vers le navigateur
$channel->flush();
$response->sendHeaders();

Paramétrer les styles pour les priorités

Les priorités incorporées et celles définies par l'utilisateur peuvent être stylisées avec la méthode setPriorityStyle().

$logger->addPriority('FOO', 8);
$writer->setPriorityStyle(8, 'TRACE');
$logger->foo('Foo Message');

Le style par défaut pour les priorités définies par l'utilisateur peut être paramétrer avec la méthode setDefaultPriorityStyle().

$writer->setDefaultPriorityStyle('TRACE');

Les styles supportés sont les suivants :

Styles de journalisation de Firebug
Style Description
LOG Affiche un message de journalisation basique
INFO Affiche un message de journalisation de type information
WARN Affiche un message de journalisation de type avertissement
ERROR Affiche un message de journalisation de type erreur (celui-ci incrémente le compteur d'erreur de Firebug)
TRACE Affiche un message de journalisation avec une trace extensible
EXCEPTION Affiche un message de journalisation de type erreur avec une trace extensible
TABLE Affiche un message de journalisation avec une table extensible

Préparer les données pour la journalisation

Toute variable PHP peut être journalisée avec les priorités incorporées, un formatage spécial est requis si vous utilisez des styles de journalisation un peu plus spécialisé.

Les styles LOG, INFO, WARN, ERROR et TRACE ne requièrent pas de formatage spécial.

Journalisation des exceptions

Pour journaliser une Zend_Exception, fournissez simplement l'objet exception au logguer. Il n'y a pas d'importance sur la priorité ou le style que vous avez fourni puisque l'exception est automatiquement reconnue.

$exception = new Zend_Exception('Test d\'exception');
$logger->err($exception);

Journalisation sous forme de tableau

Vous pouvez aussi journaliser des données en les formatant comme un tableau. Les colonnes sont automatiquement reconnues et la première ligne de données devient automatiquement la ligne d'entêtes.

$writer->setPriorityStyle(8, 'TABLE');
$logger->addPriority('TABLE', 8);

$table = array('Ligne de résumé pour la table',
               array(
                   array('Colonne 1', 'Colonne 2'),
                   array('Ligne 1 c 1',' Ligne 1 c 2'),
                   array('Ligne 2 c 1',' Ligne 2 c 2')
               )
              );
$logger->table($table);

Déraciner les rédacteurs

Le Zend_Log_Writer_Null est une souche qui écrit des données de log nulle part. Il est utile pour neutraliser le log ou déraciner le log pendant les essais :

$redacteur = new Zend_Log_Writer_Null;
$logger = new Zend_Log($redacteur);

// va nulle part
$logger->info("Message d'information");

Tester avec un simulacre

Le Zend_Log_Writer_Mock est un rédacteur très simple qui enregistre les données brutes qu'il reçoit dans un tableau exposé comme propriété publique.

$simulacre = new Zend_Log_Writer_Mock;
$logger = new Zend_Log($simulacre);

$logger->info("Message d'information");

var_dump($mock->events[0]);

// Array
// (
//    [timestamp] => 2007-04-06T07:16:37-07:00
//    [message] => Message d'information
//    [priority] => 6
//    [priorityName] => INFO
// )

Pour effacer les événements notés dans le simulacre, il faut simplement réaliser $simulacre->events = array().

Additionner les rédacteurs

Il n'y a aucun objet composite de rédacteurs. Cependant, une instance d'enregistreur peut écrire vers tout nombre de rédacteurs. Pour faire ceci, employer la méthode addWriter() :

$redacteur1 =
    new Zend_Log_Writer_Stream('/chemin/vers/premier/fichierdelog');
$redacteur2 =
    new Zend_Log_Writer_Stream('/chemin/vers/second/fichierdelog');

$logger = new Zend_Log();
$logger->addWriter($redacteur1);
$logger->addWriter($redacteur2);

// va dans les 2 rédacteurs
$logger->info("Message d'information");

Previous Next
Introduction to Zend Framework
Présentation
Installation
Zend_Acl
Introduction
Affiner les Contrôles d'Accès
Utilisation avancée
Zend_Amf
Introduction
Zend_Amf_Server
Zend_Auth
Introduction
Authentification avec une table de base de données
Authentification "Digest"
Adaptateur d'authentification HTTP
LDAP Authentication
Authentification OpenID
Zend_Cache
Introduction
Aspect théorique
Les frontends Zend_Cache
Les backends Zend_Cache
Zend_Captcha
Introduction
Opération Captcha
Adaptateurs Captcha
Zend_Config
Introduction
Aspect théorique
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Introduction à Getopt
Déclarer les règles Getopt
Extraire les options et les arguments
Configurer Zend_Console_Getopt
Zend_Controller
Zend_Controller - Démarrage rapide
Fondations de Zend_Controller
Le contrôleur frontal (Front Controller)
L'objet Requête
Routeur Standard
Le dispatcheur
Contrôleurs d'action
Aides d'action (Helper)
Objet de réponse
Plugins
Utilisation de conventions de dossiers modulaires
Exceptions avec MVC
Migrer depuis des versions précédentes
Zend_Currency
Introduction à Zend_Currency
How to work with currencies
Migrer depuis des versions antérieures
Zend_Date
Introduction
Aspect théorique
Méthodes de base
Zend_Date API Overview
Créer des dates
Constants for General Date Functions
Exemples concrets
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Relations Zend_Db_Table
Zend_Debug
Afficher des informations
Zend_Dojo
Introduction
Zend_Dojo_Data: dojo.data Envelopes
Les aides de vues Dojo
Les éléments de formulaire et les décorateurs Dojo
Zend_Dom
Introduction
Zend_Dom_Query
Zend_Exception
Utiliser les exceptions
Zend_Feed
Introduction
Importer des flux
Obtenir des flux à partir de pages Web
Consommer un flux RSS
Consommer un flux Atom
Consommer une entrée Atom particulière
Modifier la structure du flux ou des entrées
Classes personnalisées pour les flux et entrées
Zend_File
Zend_File_Transfer
Validateurs pour Zend_File_Transfer
Filtres pour Zend_File_Transfer
Migrer à partir des versions précédentes
Zend_Filter
Introduction
Classes de filtre standards
Chaînes de filtrage
Écriture de filtres
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Zend_Form Quick Start
Creating Form Elements Using Zend_Form_Element
Creating Forms Using Zend_Form
Creating Custom Form Markup Using Zend_Form_Decorator
Standard Form Elements Shipped With Zend Framework
Standard Form Decorators Shipped With Zend Framework
Internationalization of Zend_Form
Advanced Zend_Form Usage
Zend_Gdata
Introduction to Gdata
Authentification par procédé AuthSub
Using the Book Search Data API
Authentification avec ClientLogin
Using Google Calendar
Using Google Documents List Data API
Using Google Health
Using Google Spreadsheets
Using Google Apps Provisioning
Using Google Base
Utilisation des albums Web Picasa
Using the YouTube Data API
Attraper les exceptions Gdata
Zend_Http
Zend_Http_Client - Introduction
Zend_Http_Client - Utilisation avancée
Zend_Http_Client - Adaptateurs de connexion
Zend_Http_Cookie and Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Introduction
Zend_Json
Introduction
Utilisation de base
Objets JSON
XML to JSON conversion
Zend_Json_Server - JSON-RPC server
Zend_Layout
Introduction
Zend_Layout - Démarrage rapide
Zend_Layout options de configuration
Zend_Layout, utilisation avancée
Zend_Ldap
Introduction
Zend_Loader
Charger les fichiers et les classes dynamiquement
Chargeur de Plugins
Zend_Locale
Introduction
Using Zend_Locale
Normalization and Localization
Working with Dates and Times
Supported locales
Migrer à partir des versions précédentes
Zend_Log
Présentation
Rédacteurs (Writers)
Formateurs (mise en forme)
Filtres
Zend_Mail
Introduction
Envoyer des émail en utilisant SMTP
Envoyer plusieurs émail par connexion SMTP
Utiliser différents transports
Émail HTML
Fichiers joints
Ajouter des destinataires
Contrôler les limites MIME
Entêtes additionnelles
Jeux de caractères
Encodage
Authentification SMTP
Sécuriser les transports SMTP
Lire des émail
Zend_Measure
Introduction
Création d'une mesure
Récupérer des mesures
Manipuler des mesures
Types de mesures
Zend_Memory
Présentation
Manager de mémoire
Objet mémoire
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_OpenId
Introduction
Zend_OpenId_Consumer Basics
Zend_OpenId_Provider
Zend_Paginator
Introduction
Utilisation
Configuration
Utilisation avancée
Zend_Pdf
Introduction.
Créer et charger des documents PDF
Sauvegarder les changement dans un document PDF
Les pages d'un document
Dessiner
Informations du document et métadonnées.
Exemple d'utilisation du module Zend_Pdf
Zend_ProgressBar
Zend_ProgressBar
Zend_Registry
Utiliser le registre
Zend_Rest
Introduction
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Overview
Building Indexes
Searching an Index
Query Language
Query Construction API
Jeu de caractères
Extensibility
Agir avec Lucene Java
Avancé
Best Practices
Zend_Server
Introduction
Zend_Server_Reflection
Zend_Service
Introduction
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_Flickr
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Introduction
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Bundled Services
Zend_Service_StrikeIron: Advanced Uses
Zend_Service_Technorati
Zend_Service_Twitter
Zend_Service_Yahoo
Zend_Session
Introduction
Usage basique
Utilisation avancée
Gestion générale de la session
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL
Auto découverte
Zend_Test
Introduction
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Introduction
Utiliser Zend_TimeSync
Zend_Translate
Introduction
Adaptateurs pour Zend_Translate
Utiliser les adaptateurs de traduction
Migrer à partir des versions précédentes
Zend_Uri
Zend_Uri
Zend_Validate
Introduction
Classes de validation standard
Chaînes de validation
Écrire des validateurs
Zend_Version
Lire la version du Zend Framework
Zend_View
Introduction
Scripts de contrôleur
Scripts de vue
Aides de vue
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Introduction
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Configuration système requise par le Zend Framework
Version de PHP requise
Extensions PHP
Les composants du Zend Framework
Dépendances internes du Zend Framework
Convention de codage PHP du Zend Framework
Vue d'ensemble
Formatage des fichiers PHP
Conventions de nommage
Style de codage
Zend Framework Performance Guide
Introduction
Class Loading
Internationalisation (i18n) and Localisation (l10n)
View Rendering
Informations de copyright