[Summary view] [Print] [Text view]

   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 . '/LoggerLevel.php');
  27  require_once (LOG4PHP_DIR . '/spi/LoggerLoggingEvent.php');
  28  
  29  /**
  30   * This class has been deprecated and replaced by the Logger subclass.
  31   *
  32   * @author VxR <[email protected]>
  33   * @version $Revision: 1.17 $
  34   * @package log4php
  35   * @see Logger
  36   */
  37  class LoggerCategory {
  38  
  39      /**
  40       * Additivity is set to true by default, that is children inherit the 
  41       * appenders of their ancestors by default.
  42       * @var boolean
  43       */
  44      var $additive       = true;
  45      
  46      /**
  47       * @var string fully qualified class name
  48       */  
  49      var $fqcn           = 'LoggerCategory';
  50  
  51      /**
  52       * @var LoggerLevel The assigned level of this category.
  53       */
  54      var $level          = null;
  55      
  56      /**
  57       * @var string name of this category.
  58       */
  59      var $name           = '';
  60      
  61      /**
  62       * @var Logger The parent of this category.
  63       */
  64      var $parent         = null;
  65  
  66      /**
  67       * @var LoggerHierarchy the object repository
  68       */
  69      var $repository     = null; 
  70  
  71      /**
  72       * @var array collection of appenders
  73       * @see LoggerAppender
  74       */
  75      var $aai            = array();
  76      
  77  /* --------------------------------------------------------------------------*/
  78  /* --------------------------------------------------------------------------*/
  79  /* --------------------------------------------------------------------------*/
  80  
  81      /**
  82       * Constructor.
  83       *
  84       * @param  string  $name  Category name   
  85       */
  86      function LoggerCategory($name)
  87      {
  88          $this->name = $name;
  89      }
  90      
  91      /**
  92       * Add a new Appender to the list of appenders of this Category instance.
  93       *
  94       * @param LoggerAppender $newAppender
  95       */
  96      function addAppender(&$newAppender)
  97      {
  98          $appenderName = $newAppender->getName();
  99          $this->aai[$appenderName] =& $newAppender;
 100      } 
 101              
 102      /**
 103       * If assertion parameter is false, then logs msg as an error statement.
 104       *
 105       * @param bool $assertion
 106       * @param string $msg message to log
 107       */
 108      function assertLog($assertion = true, $msg = '')
 109      {
 110          if ($assertion == false) {
 111              $this->error($msg);
 112          }
 113      } 
 114  
 115      /**
 116       * Call the appenders in the hierarchy starting at this.
 117       *
 118       * @param LoggerLoggingEvent $event 
 119       */
 120      function callAppenders($event) 
 121      {
 122          if (sizeof($this->aai) > 0) {
 123              foreach (array_keys($this->aai) as $appenderName) {
 124                  $this->aai[$appenderName]->doAppend($event);
 125              }
 126          }
 127          if ($this->parent != null and $this->getAdditivity()) {
 128              $this->parent->callAppenders($event);
 129          }
 130      }
 131      
 132      /**
 133       * Log a message object with the DEBUG level including the caller.
 134       *
 135       * @param mixed $message message
 136       * @param mixed $caller caller object or caller string id
 137       */
 138      function debug($message, $caller = null)
 139      {
 140          $debugLevel = LoggerLevel::getLevelDebug();
 141          if ($this->repository->isDisabled($debugLevel)) {
 142              return;
 143          }
 144          if ($debugLevel->isGreaterOrEqual($this->getEffectiveLevel())) {
 145              $this->forcedLog($this->fqcn, $caller, $debugLevel, $message);
 146          }
 147      } 
 148  
 149      /**
 150       * Log a message object with the ERROR level including the caller.
 151       *
 152       * @param mixed $message message
 153       * @param mixed $caller caller object or caller string id
 154       */
 155      function error($message, $caller = null)
 156      {
 157          $errorLevel = LoggerLevel::getLevelError();
 158          if ($this->repository->isDisabled($errorLevel)) {
 159              return;
 160          }
 161          if ($errorLevel->isGreaterOrEqual($this->getEffectiveLevel())) {
 162              $this->forcedLog($this->fqcn, $caller, $errorLevel, $message);
 163          }
 164      }
 165    
 166      /**
 167       * Deprecated. Please use LoggerManager::exists() instead.
 168       *
 169       * @param string $name
 170       * @see LoggerManager::exists()
 171       * @deprecated
 172       */
 173      function exists($name)
 174      {
 175          return LoggerManager::exists($name);
 176      } 
 177   
 178      /**
 179       * Log a message object with the FATAL level including the caller.
 180       *
 181       * @param mixed $message message
 182       * @param mixed $caller caller object or caller string id
 183       */
 184      function fatal($message, $caller = null)
 185      {
 186          $fatalLevel = LoggerLevel::getLevelFatal();
 187          if ($this->repository->isDisabled($fatalLevel)) {
 188              return;
 189          }
 190          if ($fatalLevel->isGreaterOrEqual($this->getEffectiveLevel())) {
 191              $this->forcedLog($this->fqcn, $caller, $fatalLevel, $message);
 192          }
 193      } 
 194    
 195      /**
 196       * This method creates a new logging event and logs the event without further checks.
 197       *
 198       * It should not be called directly. Use {@link info()}, {@link debug()}, {@link warn()},
 199       * {@link error()} and {@link fatal()} wrappers.
 200       *
 201       * @param string $fqcn Fully Qualified Class Name of the Logger
 202       * @param mixed $caller caller object or caller string id
 203       * @param LoggerLevel $level log level     
 204       * @param mixed $message message
 205       * @see LoggerLoggingEvent          
 206       */
 207      function forcedLog($fqcn, $caller, $level, $message)
 208      {
 209          // $fqcn = is_object($caller) ? get_class($caller) : (string)$caller;
 210          $this->callAppenders(new LoggerLoggingEvent($fqcn, $this, $level, $message));
 211      } 
 212  
 213      /**
 214       * Get the additivity flag for this Category instance.
 215       * @return boolean
 216       */
 217      function getAdditivity()
 218      {
 219          return $this->additive;
 220      }
 221   
 222      /**
 223       * Get the appenders contained in this category as an array.
 224       * @return array collection of appenders
 225       */
 226      function &getAllAppenders() 
 227      {
 228          $appenders = array();
 229          $appenderNames = array_keys($this->aai);
 230          $enumAppenders = sizeof($appenderNames);
 231          for ($i = 0; $i < $enumAppenders; $i++) {
 232              $appenderName = $appenderNames[$i];
 233              $appenders[] =& $this->aai[$appenderName];
 234          }
 235          return $appenders; 
 236      }
 237      
 238      /**
 239       * Look for the appender named as name.
 240       * @return LoggerAppender
 241       */
 242      function &getAppender($name) 
 243      {
 244          return $this->aai[$name];
 245      }
 246      
 247      /**
 248       * Please use the {@link getEffectiveLevel()} method instead.
 249       * @deprecated
 250       */
 251      function getChainedPriority()
 252      {
 253          return $this->getEffectiveLevel();
 254      } 
 255   
 256      /**
 257       * Please use {@link LoggerManager::getCurrentLoggers()} instead.
 258       * @deprecated
 259       */
 260      function getCurrentCategories()
 261      {
 262          return LoggerManager::getCurrentLoggers();
 263      } 
 264   
 265      /**
 266       * Please use {@link LoggerManager::getLoggerRepository()} instead.
 267       * @deprecated 
 268       */
 269      function &getDefaultHierarchy()
 270      {
 271          return LoggerManager::getLoggerRepository();
 272      } 
 273   
 274      /**
 275       * @deprecated Use {@link getLoggerRepository()}
 276       * @return LoggerHierarchy 
 277       */
 278      function &getHierarchy()
 279      {
 280          return $this->getLoggerRepository();
 281      } 
 282  
 283      /**
 284       * Starting from this category, search the category hierarchy for a non-null level and return it.
 285       * @see LoggerLevel
 286       * @return LoggerLevel or null
 287       */
 288      function getEffectiveLevel()
 289      {
 290          for($c = $this; $c != null; $c = $c->parent) {
 291              if($c->level !== null)
 292                  return $c->level;
 293          }
 294          return null;
 295      }
 296    
 297      /**
 298       * Retrieve a category with named as the name parameter.
 299       * @return Logger
 300       */
 301      function &getInstance($name)
 302      {
 303          return LoggerManager::getLogger($name);
 304      }
 305  
 306      /**
 307       * Returns the assigned Level, if any, for this Category.
 308       * @return LoggerLevel or null 
 309       */
 310      function getLevel()
 311      {
 312          return $this->level;
 313      } 
 314  
 315      /**
 316       * Return the the repository where this Category is attached.
 317       * @return LoggerHierarchy
 318       */
 319      function &getLoggerRepository()
 320      {
 321          return $this->repository;
 322      } 
 323  
 324      /**
 325       * Return the category name.
 326       * @return string
 327       */
 328      function getName()
 329      {
 330          return $this->name;
 331      } 
 332  
 333      /**
 334       * Returns the parent of this category.
 335       * @return Logger
 336       */
 337      function &getParent() 
 338      {
 339          return $this->parent;
 340      }      
 341  
 342      /**
 343       * Please use getLevel() instead.
 344       * @deprecated
 345       */
 346      function getPriority()
 347      {
 348          return $this->getLevel();
 349      }
 350            
 351      /**
 352       * Return the inherited ResourceBundle for this category.
 353       */
 354      function getResourceBundle()
 355      {
 356          return;
 357      } 
 358  
 359      /**
 360       * Returns the string resource coresponding to key in this category's inherited resource bundle.
 361       */
 362      function getResourceBundleString($key)
 363      {
 364          return;
 365      } 
 366  
 367      /**
 368       * Return the root of the default category hierrachy.
 369       * @return LoggerRoot
 370       */
 371      function &getRoot()
 372      {
 373          return LoggerManager::getRootLogger();
 374      } 
 375  
 376      /**
 377       * Log a message object with the INFO Level.
 378       *
 379       * @param mixed $message message
 380       * @param mixed $caller caller object or caller string id
 381       */
 382      function info($message, $caller = null)
 383      {
 384          $infoLevel = LoggerLevel::getLevelInfo();
 385          if ($this->repository->isDisabled($infoLevel)) {
 386              return;
 387          }
 388          if ($infoLevel->isGreaterOrEqual($this->getEffectiveLevel())) {
 389              $this->forcedLog($this->fqcn, $caller, $infoLevel, $message);
 390          }
 391      }
 392       
 393      /**
 394       * Is the appender passed as parameter attached to this category?
 395       *
 396       * @param LoggerAppender $appender
 397       */
 398      function isAttached($appender)
 399      {
 400          return in_array($appender->getName(), array_keys($this->aai));
 401      } 
 402             
 403      /**
 404       * Check whether this category is enabled for the DEBUG Level.
 405       * @return boolean
 406       */
 407      function isDebugEnabled()
 408      {
 409          $debugLevel = LoggerLevel::getLevelDebug(); 
 410          if ($this->repository->isDisabled($debugLevel)) {
 411              return false;
 412          }
 413          return ($debugLevel->isGreaterOrEqual($this->getEffectiveLevel()));
 414      }       
 415  
 416      /**
 417       * Check whether this category is enabled for a given Level passed as parameter.
 418       *
 419       * @param LoggerLevel level
 420       * @return boolean
 421       */
 422      function isEnabledFor($level)
 423      {
 424          if ($this->repository->isDisabled($level)) {
 425              return false;
 426          }
 427          return (bool)($level->isGreaterOrEqual($this->getEffectiveLevel()));
 428      } 
 429  
 430      /**
 431       * Check whether this category is enabled for the info Level.
 432       * @return boolean
 433       * @see LoggerLevel
 434       */
 435      function isInfoEnabled()
 436      {
 437          $infoLevel = LoggerLevel::getLevelInfo();
 438          if ($this->repository->isDisabled($infoLevel)) {
 439              return false;
 440          }
 441          return ($infoLevel->isGreaterOrEqual($this->getEffectiveLevel()));
 442      } 
 443  
 444      /**
 445       * Log a localized and parameterized message.
 446       */
 447      function l7dlog($priority, $key, $params, $t)
 448      {
 449          return;
 450      } 
 451  
 452      /**
 453       * This generic form is intended to be used by wrappers.
 454       *
 455       * @param LoggerLevel $priority a valid level
 456       * @param mixed $message message
 457       * @param mixed $caller caller object or caller string id
 458       */
 459      function log($priority, $message, $caller = null)
 460      {
 461          if ($this->repository->isDisabled($priority)) {
 462              return;
 463          }
 464          if ($priority->isGreaterOrEqual($this->getEffectiveLevel())) {
 465              $this->forcedLog($this->fqcn, $caller, $priority, $message);
 466          }
 467      }
 468  
 469      /**
 470       * Remove all previously added appenders from this Category instance.
 471       */
 472      function removeAllAppenders()
 473      {
 474          $appenderNames = array_keys($this->aai);
 475          $enumAppenders = sizeof($appenderNames);
 476          for ($i = 0; $i < $enumAppenders; $i++) {
 477              $this->removeAppender($appenderNames[$i]); 
 478          }
 479      } 
 480              
 481      /**
 482       * Remove the appender passed as parameter form the list of appenders.
 483       *
 484       * @param mixed $appender can be an appender name or a {@link LoggerAppender} object
 485       */
 486      function removeAppender($appender)
 487      {
 488          if (is_a($appender, 'loggerappender')) {
 489              $appender->close();
 490              unset($this->aai[$appender->getName()]);
 491          } elseif (is_string($appender) and isset($this->aai[$appender])) {
 492              $this->aai[$appender]->close();
 493              unset($this->aai[$appender]);
 494          }
 495      } 
 496  
 497      /**
 498       * Set the additivity flag for this Category instance.
 499       *
 500       * @param boolean $additive
 501       */
 502      function setAdditivity($additive) 
 503      {
 504          $this->additive = (bool)$additive;
 505      }
 506      
 507      /**
 508       * @deprecated Please use {@link setLevel()} instead.
 509       * @see setLevel()
 510       */
 511      function setPriority($priority)
 512      {
 513          $this->setLevel($priority);
 514      } 
 515  
 516      /**
 517       * Only the Hiearchy class can set the hiearchy of a
 518       * category.
 519       *
 520       * @param LoggerHierarchy &$repository
 521       */
 522      function setHierarchy(&$repository)
 523      {
 524          $this->repository =& $repository;
 525      }
 526  
 527      /**
 528       * Set the level of this Category.
 529       *
 530       * @param LoggerLevel $level a level string or a level costant 
 531       */
 532      function setLevel($level)
 533      {
 534          $this->level = $level;
 535      } 
 536  
 537      /**
 538       * Set the resource bundle to be used with localized logging methods 
 539       */
 540      function setResourceBundle($bundle)
 541      {
 542          return;
 543      } 
 544             
 545      /**
 546       * @deprecated use {@link LoggerManager::shutdown()} instead.
 547       * @see LoggerManager::shutdown()
 548       */
 549      function shutdown()
 550      {
 551          LoggerManager::shutdown();
 552      } 
 553   
 554      /**
 555       * Log a message with the WARN level.
 556       *
 557       * @param mixed $message message
 558       * @param mixed $caller caller object or caller string id
 559       */
 560      function warn($message, $caller = null)
 561      {
 562          $warnLevel = LoggerLevel::getLevelWarn();
 563          if ($this->repository->isDisabled($warnLevel)) {
 564              return;
 565          }
 566          if ($warnLevel->isGreaterOrEqual($this->getEffectiveLevel())) {
 567              $this->forcedLog($this->fqcn, $caller, $warnLevel, $message);
 568          }
 569      }
 570  
 571  }  
 572  ?>