1. sfLogger.class.php
  2. /**
 * sfLogger is the abstract class for all logging classes.
 *
 * This level list is ordered by highest priority (self::EMERG) to lowest priority (self::DEBUG):
 * - EMERG:   System is unusable
 * - ALERT:   Immediate action required
 * - CRIT:    Critical conditions
 * - ERR:     Error conditions
 * - WARNING: Warning conditions
 * - NOTICE:  Normal but significant
 * - INFO:    Informational
 * - DEBUG:   Debug-level messages
 *
 * @package    symfony
 * @subpackage log
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfLogger.class.php 23810 2009-11-12 11:07:44Z Kris.Wallsmith $
 */
  3. abstract class sfLogger
  4. {
  5.   const EMERG   = 0; // System is unusable
  6.   const ALERT   = 1; // Immediate action required
  7.   const CRIT    = 2; // Critical conditions
  8.   const ERR     = 3; // Error conditions
  9.   const WARNING = 4; // Warning conditions
  10.   const NOTICE  = 5; // Normal but significant
  11.   const INFO    = 6; // Informational
  12.   const DEBUG   = 7; // Debug-level messages
  14.   protected
  15.     $dispatcher = null,
  16.     $options = array(),
  17.     $level = self::INFO;
  19.   /**
  20.    * Class constructor.
  21.    *
  22.    * @see initialize()
  23.    */
  24.   public function __construct(sfEventDispatcher $dispatcher, $options = array())
  25.   {
  26.     $this->initialize($dispatcher, $options);
  28.     if (!isset($options['auto_shutdown']) || $options['auto_shutdown'])
  29.     {
  30.       register_shutdown_function(array($this, 'shutdown'));
  31.     }
  32.   }
  34.   /**
  35.    * Initializes this sfLogger instance.
  36.    *
  37.    * Available options:
  38.    *
  39.    * - level: The log level.
  40.    *
  41.    * @param  sfEventDispatcher $dispatcher  A sfEventDispatcher instance
  42.    * @param  array             $options     An array of options.
  43.    *
  44.    * @return Boolean      true, if initialization completes successfully, otherwise false.
  45.    *
  46.    * @throws <b>sfInitializationException</b> If an error occurs while initializing this sfLogger.
  47.    */
  48.   public function initialize(sfEventDispatcher $dispatcher, $options = array())
  49.   {
  50.     $this->dispatcher = $dispatcher;
  51.     $this->options = $options;
  52.     
  53.     if (isset($this->options['level']))
  54.     {
  55.       $this->setLogLevel($this->options['level']);
  56.     }
  58.     $dispatcher->connect('application.log', array($this, 'listenToLogEvent'));
  59.   }
  60.   
  61.   /**
  62.    * Returns the options for the logger instance.
  63.    */
  64.   public function getOptions()
  65.   {
  66.     return $this->options;
  67.   }
  68.   
  69.   /**
  70.    * Returns the options for the logger instance.
  71.    */
  72.   public function setOption($name, $value)
  73.   {
  74.     $this->options[$name] = $value;
  75.   }
  77.   /**
  78.    * Retrieves the log level for the current logger instance.
  79.    *
  80.    * @return string Log level
  81.    */
  82.   public function getLogLevel()
  83.   {
  84.     return $this->level;
  85.   }
  87.   /**
  88.    * Sets a log level for the current logger instance.
  89.    *
  90.    * @param string $level Log level
  91.    */
  92.   public function setLogLevel($level)
  93.   {
  94.     if (!is_int($level))
  95.     {
  96.       $level = constant('sfLogger::'.strtoupper($level));
  97.     }
  99.     $this->level = $level;
  100.   }
  102.   /**
  103.    * Logs a message.
  104.    *
  105.    * @param string $message   Message
  106.    * @param string $priority  Message priority
  107.    */
  108.   public function log($message, $priority = self::INFO)
  109.   {
  110.     if ($this->getLogLevel() < $priority)
  111.     {
  112.       return false;
  113.     }
  115.     return $this->doLog($message, $priority);
  116.   }
  118.   /**
  119.    * Logs a message.
  120.    *
  121.    * @param string $message   Message
  122.    * @param string $priority  Message priority
  123.    */
  124.   abstract protected function doLog($message, $priority);
  126.   /**
  127.    * Logs an emerg message.
  128.    *
  129.    * @param string $message Message
  130.    */
  131.   public function emerg($message)
  132.   {
  133.     $this->log($message, self::EMERG);
  134.   }
  136.   /**
  137.    * Logs an alert message.
  138.    *
  139.    * @param string $message Message
  140.    */
  141.   public function alert($message)
  142.   {
  143.     $this->log($message, self::ALERT);
  144.   }
  146.   /**
  147.    * Logs a critical message.
  148.    *
  149.    * @param string $message Message
  150.    */
  151.   public function crit($message)
  152.   {
  153.     $this->log($message, self::CRIT);
  154.   }
  156.   /**
  157.    * Logs an error message.
  158.    *
  159.    * @param string $message Message
  160.    */
  161.   public function err($message)
  162.   {
  163.     $this->log($message, self::ERR);
  164.   }
  166.   /**
  167.    * Logs a warning message.
  168.    *
  169.    * @param string $message Message
  170.    */
  171.   public function warning($message)
  172.   {
  173.     $this->log($message, self::WARNING);
  174.   }
  176.   /**
  177.    * Logs a notice message.
  178.    *
  179.    * @param string $message Message
  180.    */
  181.   public function notice($message)
  182.   {
  183.     $this->log($message, self::NOTICE);
  184.   }
  186.   /**
  187.    * Logs an info message.
  188.    *
  189.    * @param string $message Message
  190.    */
  191.   public function info($message)
  192.   {
  193.     $this->log($message, self::INFO);
  194.   }
  196.   /**
  197.    * Logs a debug message.
  198.    *
  199.    * @param string $message Message
  200.    */
  201.   public function debug($message)
  202.   {
  203.     $this->log($message, self::DEBUG);
  204.   }
  206.   /**
  207.    * Listens to application.log events.
  208.    *
  209.    * @param sfEvent $event An sfEvent instance
  210.    */
  211.   public function listenToLogEvent(sfEvent $event)
  212.   {
  213.     $priority = isset($event['priority']) ? $event['priority'] : self::INFO;
  215.     $subject  = $event->getSubject();
  216.     $subject  = is_object($subject) ? get_class($subject) : (is_string($subject) ? $subject : 'main');
  217.     foreach ($event->getParameters() as $key => $message)
  218.     {
  219.       if ('priority' === $key)
  220.       {
  221.         continue;
  222.       }
  224.       $this->log(sprintf('{%s} %s', $subject, $message), $priority);
  225.     }
  226.   }
  228.   /**
  229.    * Executes the shutdown procedure.
  230.    *
  231.    * Cleans up the current logger instance.
  232.    */
  233.   public function shutdown()
  234.   {
  235.   }
  237.   /**
  238.    * Returns the priority name given a priority class constant
  239.    *
  240.    * @param  integer $priority A priority class constant
  241.    *
  242.    * @return string  The priority name
  243.    *
  244.    * @throws sfException if the priority level does not exist
  245.    */
  246.   static public function getPriorityName($priority)
  247.   {
  248.     static $levels  = array(
  249.       self::EMERG   => 'emerg',
  250.       self::ALERT   => 'alert',
  251.       self::CRIT    => 'crit',
  252.       self::ERR     => 'err',
  253.       self::WARNING => 'warning',
  254.       self::NOTICE  => 'notice',
  255.       self::INFO    => 'info',
  256.       self::DEBUG   => 'debug',
  257.     );
  259.     if (!isset($levels[$priority]))
  260.     {
  261.       throw new sfException(sprintf('The priority level "%s" does not exist.', $priority));
  262.     }
  264.     return $levels[$priority];
  265.   }
  266. }
Debug toolbar