| <?php | |
| /** | |
| * $Header$ | |
| * $Horde: horde/lib/Log.php,v 1.15 2000/06/29 23:39:45 jon Exp $ | |
| * | |
| * @version $Revision: 302787 $ | |
| * @package Log | |
| */ | |
| define('PEAR_LOG_EMERG', 0); /* System is unusable */ | |
| define('PEAR_LOG_ALERT', 1); /* Immediate action required */ | |
| define('PEAR_LOG_CRIT', 2); /* Critical conditions */ | |
| define('PEAR_LOG_ERR', 3); /* Error conditions */ | |
| define('PEAR_LOG_WARNING', 4); /* Warning conditions */ | |
| define('PEAR_LOG_NOTICE', 5); /* Normal but significant */ | |
| define('PEAR_LOG_INFO', 6); /* Informational */ | |
| define('PEAR_LOG_DEBUG', 7); /* Debug-level messages */ | |
| define('PEAR_LOG_ALL', 0xffffffff); /* All messages */ | |
| define('PEAR_LOG_NONE', 0x00000000); /* No message */ | |
| /* Log types for PHP's native error_log() function. */ | |
| define('PEAR_LOG_TYPE_SYSTEM', 0); /* Use PHP's system logger */ | |
| define('PEAR_LOG_TYPE_MAIL', 1); /* Use PHP's mail() function */ | |
| define('PEAR_LOG_TYPE_DEBUG', 2); /* Use PHP's debugging connection */ | |
| define('PEAR_LOG_TYPE_FILE', 3); /* Append to a file */ | |
| define('PEAR_LOG_TYPE_SAPI', 4); /* Use the SAPI logging handler */ | |
| /** | |
| * The Log:: class implements both an abstraction for various logging | |
| * mechanisms and the Subject end of a Subject-Observer pattern. | |
| * | |
| * @author Chuck Hagenbuch <chuck@horde.org> | |
| * @author Jon Parise <jon@php.net> | |
| * @since Horde 1.3 | |
| * @package Log | |
| */ | |
| class Log | |
| { | |
| /** | |
| * Indicates whether or not the log can been opened / connected. | |
| * | |
| * @var boolean | |
| * @access protected | |
| */ | |
| var $_opened = false; | |
| /** | |
| * Instance-specific unique identification number. | |
| * | |
| * @var integer | |
| * @access protected | |
| */ | |
| var $_id = 0; | |
| /** | |
| * The label that uniquely identifies this set of log messages. | |
| * | |
| * @var string | |
| * @access protected | |
| */ | |
| var $_ident = ''; | |
| /** | |
| * The default priority to use when logging an event. | |
| * | |
| * @var integer | |
| * @access protected | |
| */ | |
| var $_priority = PEAR_LOG_INFO; | |
| /** | |
| * The bitmask of allowed log levels. | |
| * | |
| * @var integer | |
| * @access protected | |
| */ | |
| var $_mask = PEAR_LOG_ALL; | |
| /** | |
| * Holds all Log_observer objects that wish to be notified of new messages. | |
| * | |
| * @var array | |
| * @access protected | |
| */ | |
| var $_listeners = array(); | |
| /** | |
| * Maps canonical format keys to position arguments for use in building | |
| * "line format" strings. | |
| * | |
| * @var array | |
| * @access protected | |
| */ | |
| var $_formatMap = array('%{timestamp}' => '%1$s', | |
| '%{ident}' => '%2$s', | |
| '%{priority}' => '%3$s', | |
| '%{message}' => '%4$s', | |
| '%{file}' => '%5$s', | |
| '%{line}' => '%6$s', | |
| '%{function}' => '%7$s', | |
| '%{class}' => '%8$s', | |
| '%\{' => '%%{'); | |
| /** | |
| * Attempts to return a concrete Log instance of type $handler. | |
| * | |
| * @param string $handler The type of concrete Log subclass to return. | |
| * Attempt to dynamically include the code for | |
| * this subclass. Currently, valid values are | |
| * 'console', 'syslog', 'sql', 'file', and 'mcal'. | |
| * | |
| * @param string $name The name of the actually log file, table, or | |
| * other specific store to use. Defaults to an | |
| * empty string, with which the subclass will | |
| * attempt to do something intelligent. | |
| * | |
| * @param string $ident The identity reported to the log system. | |
| * | |
| * @param array $conf A hash containing any additional configuration | |
| * information that a subclass might need. | |
| * | |
| * @param int $level Log messages up to and including this level. | |
| * | |
| * @return object Log The newly created concrete Log instance, or | |
| * null on an error. | |
| * @access public | |
| * @since Log 1.0 | |
| */ | |
| public static function factory($handler, $name = '', $ident = '', | |
| $conf = array(), $level = PEAR_LOG_DEBUG) | |
| { | |
| $handler = strtolower($handler); | |
| $class = 'Log_' . $handler; | |
| $classfile = 'Log/' . $handler . '.php'; | |
| /* | |
| * Attempt to include our version of the named class, but don't treat | |
| * a failure as fatal. The caller may have already included their own | |
| * version of the named class. | |
| */ | |
| if (!class_exists($class, false)) { | |
| include_once $classfile; | |
| } | |
| /* If the class exists, return a new instance of it. */ | |
| if (class_exists($class, false)) { | |
| $obj = new $class($name, $ident, $conf, $level); | |
| return $obj; | |
| } | |
| $null = null; | |
| return $null; | |
| } | |
| /** | |
| * Attempts to return a reference to a concrete Log instance of type | |
| * $handler, only creating a new instance if no log instance with the same | |
| * parameters currently exists. | |
| * | |
| * You should use this if there are multiple places you might create a | |
| * logger, you don't want to create multiple loggers, and you don't want to | |
| * check for the existance of one each time. The singleton pattern does all | |
| * the checking work for you. | |
| * | |
| * <b>You MUST call this method with the $var = &Log::singleton() syntax. | |
| * Without the ampersand (&) in front of the method name, you will not get | |
| * a reference, you will get a copy.</b> | |
| * | |
| * @param string $handler The type of concrete Log subclass to return. | |
| * Attempt to dynamically include the code for | |
| * this subclass. Currently, valid values are | |
| * 'console', 'syslog', 'sql', 'file', and 'mcal'. | |
| * | |
| * @param string $name The name of the actually log file, table, or | |
| * other specific store to use. Defaults to an | |
| * empty string, with which the subclass will | |
| * attempt to do something intelligent. | |
| * | |
| * @param string $ident The identity reported to the log system. | |
| * | |
| * @param array $conf A hash containing any additional configuration | |
| * information that a subclass might need. | |
| * | |
| * @param int $level Log messages up to and including this level. | |
| * | |
| * @return object Log The newly created concrete Log instance, or | |
| * null on an error. | |
| * @access public | |
| * @since Log 1.0 | |
| */ | |
| public static function singleton($handler, $name = '', $ident = '', | |
| $conf = array(), $level = PEAR_LOG_DEBUG) | |
| { | |
| static $instances; | |
| if (!isset($instances)) $instances = array(); | |
| $signature = serialize(array($handler, $name, $ident, $conf, $level)); | |
| if (!isset($instances[$signature])) { | |
| $instances[$signature] = Log::factory($handler, $name, $ident, | |
| $conf, $level); | |
| } | |
| return $instances[$signature]; | |
| } | |
| /** | |
| * Abstract implementation of the open() method. | |
| * @since Log 1.0 | |
| */ | |
| function open() | |
| { | |
| return false; | |
| } | |
| /** | |
| * Abstract implementation of the close() method. | |
| * @since Log 1.0 | |
| */ | |
| function close() | |
| { | |
| return false; | |
| } | |
| /** | |
| * Abstract implementation of the flush() method. | |
| * @since Log 1.8.2 | |
| */ | |
| function flush() | |
| { | |
| return false; | |
| } | |
| /** | |
| * Abstract implementation of the log() method. | |
| * @since Log 1.0 | |
| */ | |
| function log($message, $priority = null) | |
| { | |
| return false; | |
| } | |
| /** | |
| * A convenience function for logging a emergency event. It will log a | |
| * message at the PEAR_LOG_EMERG log level. | |
| * | |
| * @param mixed $message String or object containing the message | |
| * to log. | |
| * | |
| * @return boolean True if the message was successfully logged. | |
| * | |
| * @access public | |
| * @since Log 1.7.0 | |
| */ | |
| function emerg($message) | |
| { | |
| return $this->log($message, PEAR_LOG_EMERG); | |
| } | |
| /** | |
| * A convenience function for logging an alert event. It will log a | |
| * message at the PEAR_LOG_ALERT log level. | |
| * | |
| * @param mixed $message String or object containing the message | |
| * to log. | |
| * | |
| * @return boolean True if the message was successfully logged. | |
| * | |
| * @access public | |
| * @since Log 1.7.0 | |
| */ | |
| function alert($message) | |
| { | |
| return $this->log($message, PEAR_LOG_ALERT); | |
| } | |
| /** | |
| * A convenience function for logging a critical event. It will log a | |
| * message at the PEAR_LOG_CRIT log level. | |
| * | |
| * @param mixed $message String or object containing the message | |
| * to log. | |
| * | |
| * @return boolean True if the message was successfully logged. | |
| * | |
| * @access public | |
| * @since Log 1.7.0 | |
| */ | |
| function crit($message) | |
| { | |
| return $this->log($message, PEAR_LOG_CRIT); | |
| } | |
| /** | |
| * A convenience function for logging a error event. It will log a | |
| * message at the PEAR_LOG_ERR log level. | |
| * | |
| * @param mixed $message String or object containing the message | |
| * to log. | |
| * | |
| * @return boolean True if the message was successfully logged. | |
| * | |
| * @access public | |
| * @since Log 1.7.0 | |
| */ | |
| function err($message) | |
| { | |
| return $this->log($message, PEAR_LOG_ERR); | |
| } | |
| /** | |
| * A convenience function for logging a warning event. It will log a | |
| * message at the PEAR_LOG_WARNING log level. | |
| * | |
| * @param mixed $message String or object containing the message | |
| * to log. | |
| * | |
| * @return boolean True if the message was successfully logged. | |
| * | |
| * @access public | |
| * @since Log 1.7.0 | |
| */ | |
| function warning($message) | |
| { | |
| return $this->log($message, PEAR_LOG_WARNING); | |
| } | |
| /** | |
| * A convenience function for logging a notice event. It will log a | |
| * message at the PEAR_LOG_NOTICE log level. | |
| * | |
| * @param mixed $message String or object containing the message | |
| * to log. | |
| * | |
| * @return boolean True if the message was successfully logged. | |
| * | |
| * @access public | |
| * @since Log 1.7.0 | |
| */ | |
| function notice($message) | |
| { | |
| return $this->log($message, PEAR_LOG_NOTICE); | |
| } | |
| /** | |
| * A convenience function for logging a information event. It will log a | |
| * message at the PEAR_LOG_INFO log level. | |
| * | |
| * @param mixed $message String or object containing the message | |
| * to log. | |
| * | |
| * @return boolean True if the message was successfully logged. | |
| * | |
| * @access public | |
| * @since Log 1.7.0 | |
| */ | |
| function info($message) | |
| { | |
| return $this->log($message, PEAR_LOG_INFO); | |
| } | |
| /** | |
| * A convenience function for logging a debug event. It will log a | |
| * message at the PEAR_LOG_DEBUG log level. | |
| * | |
| * @param mixed $message String or object containing the message | |
| * to log. | |
| * | |
| * @return boolean True if the message was successfully logged. | |
| * | |
| * @access public | |
| * @since Log 1.7.0 | |
| */ | |
| function debug($message) | |
| { | |
| return $this->log($message, PEAR_LOG_DEBUG); | |
| } | |