[Sommaire] [Imprimer]

   1  <?php
   2  /**
   3   * log4php is a PHP port of the log4j java logging package.
   4   * 
   5   * <p>This framework is based on log4j (see {@link http://jakarta.apache.org/log4j log4j} for details).</p>
   6   * <p>Design, strategies and part of the methods documentation are developed by log4j team 
   7   * (Ceki Gülcü as log4j project founder and 
   8   * {@link http://jakarta.apache.org/log4j/docs/contributors.html contributors}).</p>
   9   *
  10   * <p>PHP port, extensions and modifications by VxR. All rights reserved.<br>
  11   * For more information, please see {@link http://www.vxr.it/log4php/}.</p>
  12   *
  13   * <p>This software is published under the terms of the LGPL License
  14   * a copy of which has been included with this distribution in the LICENSE file.</p>
  15   * 
  16   * @package log4php
  17   */
  18  
  19  /**
  20   * @ignore 
  21   */
  22  if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__)); 
  23  
  24  /**
  25   */
  26  require_once (LOG4PHP_DIR . '/LoggerLog.php');
  27  require_once (LOG4PHP_DIR . '/LoggerLevel.php');
  28  require_once (LOG4PHP_DIR . '/LoggerRoot.php');
  29  require_once (LOG4PHP_DIR . '/or/LoggerRendererMap.php');
  30  require_once (LOG4PHP_DIR . '/LoggerDefaultCategoryFactory.php');
  31  
  32  /**
  33   * This class is specialized in retrieving loggers by name and also maintaining 
  34   * the logger hierarchy.
  35   *
  36   * <p>The casual user does not have to deal with this class directly.</p>
  37   *
  38   * <p>The structure of the logger hierarchy is maintained by the
  39   * getLogger method. The hierarchy is such that children link
  40   * to their parent but parents do not have any pointers to their
  41   * children. Moreover, loggers can be instantiated in any order, in
  42   * particular descendant before ancestor.</p>
  43   *
  44   * <p>In case a descendant is created before a particular ancestor,
  45   * then it creates a provision node for the ancestor and adds itself
  46   * to the provision node. Other descendants of the same ancestor add
  47   * themselves to the previously created provision node.</p>
  48   *
  49   * @author VxR <vxr@vxr.it>
  50   * @version $Revision: 1.20 $
  51   * @package log4php
  52   */
  53  class LoggerHierarchy {
  54  
  55      /**
  56       * @var object currently unused
  57       */
  58      var $defaultFactory;
  59      
  60      /**
  61       * @var boolean activate internal logging
  62       * @see LoggerLog
  63       */
  64      var $debug = false;
  65  
  66      /**
  67       * @var array hierarchy tree. saves here all loggers
  68       */
  69      var $ht = array();
  70      
  71      /**
  72       * @var LoggerRoot
  73       */
  74      var $root = null;
  75      
  76      /**
  77       * @var LoggerRendererMap
  78       */
  79      var $rendererMap;
  80  
  81      /**
  82       * @var LoggerLevel main level threshold
  83       */
  84      var $threshold;
  85      
  86      /**
  87       * @var boolean currently unused
  88       */
  89      var $emittedNoAppenderWarning       = false;
  90  
  91      /**
  92       * @var boolean currently unused
  93       */
  94      var $emittedNoResourceBundleWarning = false;
  95      
  96      
  97  /* --------------------------------------------------------------------------*/
  98  /* --------------------------------------------------------------------------*/
  99  /* --------------------------------------------------------------------------*/
 100  
 101      function &singleton()
 102      {
 103          static $instance;
 104          
 105          if (!isset($instance))
 106              $instance = new LoggerHierarchy(new LoggerRoot());
 107          return $instance;
 108      }
 109      
 110      /**
 111       * Create a new logger hierarchy.
 112       * @param object $root the root logger
 113       */
 114      function LoggerHierarchy($root)
 115      {
 116          $this->root    =& $root;
 117          // Enable all level levels by default.
 118          $this->setThreshold(LoggerLevel::getLevelAll());
 119          $this->root->setHierarchy($this);
 120          $this->rendererMap = new LoggerRendererMap();
 121          $this->defaultFactory = new LoggerDefaultCategoryFactory();        
 122      }
 123       
 124      /**
 125       * Add a HierarchyEventListener event to the repository. 
 126       * Not Yet Impl.
 127       */
 128      function addHierarchyEventListener($listener)
 129      {
 130          return;
 131      }
 132       
 133      /**
 134       * Add an object renderer for a specific class.
 135       * Not Yet Impl.
 136       */
 137      function addRenderer($classToRender, $or)
 138      {
 139          $this->rendererMap->put($classToRender, $or);
 140      } 
 141      
 142      /**
 143       * This call will clear all logger definitions from the internal hashtable.
 144       */
 145      function clear()
 146      {
 147          $this->ht = array();
 148      }
 149        
 150      function emitNoAppenderWarning($cat)
 151      {
 152          return;
 153      }
 154      
 155      /**
 156       * Check if the named logger exists in the hierarchy.
 157       * @param string $name
 158       * @return boolean
 159       */
 160      function exists($name)
 161      {
 162          return in_array($name, array_keys($this->ht));
 163      }
 164  
 165      function fireAddAppenderEvent($logger, $appender)
 166      {
 167          return;
 168      }
 169      
 170      /**
 171       * @deprecated Please use {@link getCurrentLoggers()} instead.
 172       */
 173      function &getCurrentCategories()
 174      {
 175          return $this->getCurrentLoggers();
 176      }
 177      
 178      /**
 179       * Returns all the currently defined categories in this hierarchy as an array.
 180       * @return array
 181       */  
 182      function &getCurrentLoggers()
 183      {
 184          $loggers = array();
 185          $loggerNames = array_keys($this->ht);
 186          $enumLoggers = sizeof($loggerNames);
 187          for ($i = 0; $i < $enumLoggers; $i++) {
 188              $loggerName = $loggerNames[$i];
 189              $loggers[] =& $this->ht[$loggerName];
 190          }
 191          return $loggers; 
 192      }
 193      
 194      /**
 195       * Return a new logger instance named as the first parameter using the default factory.
 196       * 
 197       * @param string $name logger name
 198       * @param LoggerFactory $factory a {@link LoggerFactory} instance or null     
 199       * @return Logger
 200       */
 201      function &getLogger($name, $factory = null)
 202      {
 203          if ($factory === null) {
 204              return $this->getLoggerByFactory($name, $this->defaultFactory);
 205          } else {
 206              return $this->getLoggerByFactory($name, $factory);
 207          }
 208      } 
 209      
 210      /**
 211       * Return a new logger instance named as the first parameter using the default factory.
 212       * 
 213       * @param string $name logger name
 214       * @return Logger
 215       * @todo merge with {@link getLogger()}
 216       */
 217      function &getLoggerByFactory($name, $factory)
 218      {
 219          if (!isset($this->ht[$name])) {
 220              LoggerLog::debug("LoggerHierarchy::getLoggerByFactory():name=[$name]:factory=[".get_class($factory)."] creating a new logger...");
 221              $this->ht[$name] = $factory->makeNewLoggerInstance($name);
 222              $this->ht[$name]->setHierarchy($this);
 223              $nodes = explode('.', $name);
 224              $firstNode = array_shift($nodes);
 225              if ( $firstNode != $name and isset($this->ht[$firstNode])) {
 226                  LoggerLog::debug("LoggerHierarchy::getLogger($name) parent is now [$firstNode]");            
 227                  $this->ht[$name]->parent =& $this->ht[$firstNode];
 228              } else {
 229                  LoggerLog::debug("LoggerHierarchy::getLogger($name) parent is now [root]");            
 230                  $this->ht[$name]->parent =& $this->root;
 231              } 
 232              if (sizeof($nodes) > 0) {
 233                  // find parent node
 234                  foreach ($nodes as $node) {
 235                      $parentNode = "$firstNode.$node";
 236                      if (isset($this->ht[$parentNode]) and $parentNode != $name) {
 237                          LoggerLog::debug("LoggerHierarchy::getLogger($name) parent is now [$parentNode]");                    
 238                          $this->ht[$name]->parent =& $this->ht[$parentNode];
 239                      }
 240                      $firstNode .= ".$node";
 241                  }
 242              }
 243              // update children
 244              /*
 245              $children = array();
 246              foreach (array_keys($this->ht) as $nodeName) {
 247                  if ($nodeName != $name and substr($nodeName, 0, strlen($name)) == $name) {
 248                      $children[] = $nodeName;    
 249                  }
 250              }
 251              */
 252          }            
 253          return $this->ht[$name];
 254      }
 255      
 256      /**
 257       * @return LoggerRendererMap Get the renderer map for this hierarchy.
 258       */
 259      function &getRendererMap()
 260      {
 261          return $this->rendererMap;
 262      }
 263      
 264      /**
 265       * @return LoggerRoot Get the root of this hierarchy.
 266       */ 
 267      function &getRootLogger()
 268      {
 269          if (!isset($this->root) or $this->root == null)
 270              $this->root = new LoggerRoot();
 271          return $this->root;
 272      }
 273       
 274      /**
 275       * @return LoggerLevel Returns the threshold Level.
 276       */
 277      function getThreshold()
 278      {
 279          return $this->threshold;
 280      } 
 281  
 282      /**
 283       * This method will return true if this repository is disabled 
 284       * for level object passed as parameter and false otherwise.
 285       * @return boolean
 286       */
 287      function isDisabled($level)
 288      {
 289          return ($this->threshold->level > $level->level);
 290      }
 291      
 292      /**
 293       * @deprecated Deprecated with no replacement.
 294       */
 295      function overrideAsNeeded($override)
 296      {
 297          return;
 298      } 
 299      
 300      /**
 301       * Reset all values contained in this hierarchy instance to their
 302       * default. 
 303       *
 304       * This removes all appenders from all categories, sets
 305       * the level of all non-root categories to <i>null</i>,
 306       * sets their additivity flag to <i>true</i> and sets the level
 307       * of the root logger to {@link LOGGER_LEVEL_DEBUG}.  Moreover,
 308       * message disabling is set its default "off" value.
 309       * 
 310       * <p>Existing categories are not removed. They are just reset.
 311       *
 312       * <p>This method should be used sparingly and with care as it will
 313       * block all logging until it is completed.</p>
 314       */
 315      function resetConfiguration()
 316      {
 317          $root =& $this->getRootLogger();
 318          
 319          $root->setLevel(LoggerLevel::getLevelDebug());
 320          $this->setThreshold(LoggerLevel::getLevelAll());
 321          $this->shutDown();
 322          $loggers =& $this->getCurrentLoggers();
 323          $enumLoggers = sizeof($loggers);
 324          for ($i = 0; $i < $enumLoggers; $i++) {
 325              $loggers[$i]->setLevel(null);
 326              $loggers[$i]->setAdditivity(true);
 327              $loggers[$i]->setResourceBundle(null);
 328          }
 329          $this->rendererMap->clear();
 330      }
 331        
 332      /**
 333       * @deprecated Deprecated with no replacement.
 334       */
 335      function setDisableOverride($override)
 336      {
 337          return;
 338      }
 339      
 340      /**
 341       * Used by subclasses to add a renderer to the hierarchy passed as parameter.
 342       * @param string $renderedClass a LoggerRenderer class name
 343       * @param LoggerRenderer $renderer
 344       *
 345       */
 346      function setRenderer($renderedClass, $renderer)
 347      {
 348          $this->rendererMap->put($renderedClass, $renderer);
 349      }
 350      
 351      /**
 352       * set a new threshold level
 353       *
 354       * @param LoggerLevel $l
 355       */
 356      function setThreshold($l)
 357      {
 358          if ($l !== null)
 359              $this->threshold = $l;
 360      }
 361      
 362      /**
 363       * Shutting down a hierarchy will <i>safely</i> close and remove
 364       * all appenders in all categories including the root logger.
 365       * 
 366       * <p>Some appenders such as {@link LoggerSocketAppender}
 367       * need to be closed before the
 368       * application exists. Otherwise, pending logging events might be
 369       * lost.
 370       * 
 371       * <p>The shutdown method is careful to close nested
 372       * appenders before closing regular appenders. This is allows
 373       * configurations where a regular appender is attached to a logger
 374       * and again to a nested appender.
 375       */
 376      function shutdown()
 377      {
 378          $this->root->removeAllAppenders();
 379          $cats =& $this->getCurrentLoggers();
 380          $enumCats = sizeof($cats);        
 381          if ($enumCats > 0) {
 382              for ($i = 0; $i < $enumCats; $i++) {
 383                  $cats[$i]->removeAllAppenders();
 384              }
 385          }
 386      }  
 387  } 
 388  ?>