Log.php

Go to the documentation of this file.

<?php
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 */

class Log
{
    var $_opened = false;

    var $_id = 0;

    var $_ident = '';

    var $_priority = PEAR_LOG_INFO;

    var $_mask = PEAR_LOG_ALL;

    var $_listeners = array();

    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',
                            '%\{'           => '%%{');

    function _classExists($class)
    {
        if (version_compare(PHP_VERSION, '5.0.0', 'ge')) {
            return class_exists($class, false);
        }

        return class_exists($class);
    }

    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 (!Log::_classExists($class)) {
            include_once $classfile;
        }

        /* If the class exists, return a new instance of it. */
        if (Log::_classExists($class)) {
            $obj = &new $class($name, $ident, $conf, $level);
            return $obj;
        }

        $null = null;
        return $null;
    }

    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];
    }

    function open()
    {
        return false;
    }

    function close()
    {
        return false;
    }

    function flush()
    {
        return false;
    }

    function log($message, $priority = null)
    {
        return false;
    }

    function emerg($message)
    {
        return $this->log($message, PEAR_LOG_EMERG);
    }

    function alert($message)
    {
        return $this->log($message, PEAR_LOG_ALERT);
    }

    function crit($message)
    {
        return $this->log($message, PEAR_LOG_CRIT);
    }

    function err($message)
    {
        return $this->log($message, PEAR_LOG_ERR);
    }

    function warning($message)
    {
        return $this->log($message, PEAR_LOG_WARNING);
    }

    function notice($message)
    {
        return $this->log($message, PEAR_LOG_NOTICE);
    }

    function info($message)
    {
        return $this->log($message, PEAR_LOG_INFO);
    }

    function debug($message)
    {
        return $this->log($message, PEAR_LOG_DEBUG);
    }

    function _extractMessage($message)
    {
        /*
         * If we've been given an object, attempt to extract the message using
         * a known method.  If we can't find such a method, default to the
         * "human-readable" version of the object.
         *
         * We also use the human-readable format for arrays.
         */
        if (is_object($message)) {
            if (method_exists($message, 'getmessage')) {
                $message = $message->getMessage();
            } else if (method_exists($message, 'tostring')) {
                $message = $message->toString();
            } else if (method_exists($message, '__tostring')) {
                if (version_compare(PHP_VERSION, '5.0.0', 'ge')) {
                    $message = (string)$message;
                } else {
                    $message = $message->__toString();
                }
            } else {
                $message = var_export($message, true);
            }
        } else if (is_array($message)) {
            if (isset($message['message'])) {
                if (is_scalar($message['message'])) {
                    $message = $message['message'];
                } else {
                    $message = var_export($message['message'], true);
                }
            } else {
                $message = var_export($message, true);
            }
        } else if (is_bool($message) || $message === NULL) {
            $message = var_export($message, true);
        }

        /* Otherwise, we assume the message is a string. */
        return $message;
    }

    function _getBacktraceVars($depth)
    {
        /* Start by generating a backtrace from the current call (here). */
        $bt = debug_backtrace();

        /*
         * If we were ultimately invoked by the composite handler, we need to
         * increase our depth one additional level to compensate.
         */
        $class = isset($bt[$depth+1]['class']) ? $bt[$depth+1]['class'] : null;
        if ($class !== null && strcasecmp($class, 'Log_composite') == 0) {
            $depth++;
            $class = isset($bt[$depth + 1]) ? $bt[$depth + 1]['class'] : null;
        }

        /*
         * We're interested in the frame which invoked the log() function, so
         * we need to walk back some number of frames into the backtrace.  The
         * $depth parameter tells us where to start looking.   We go one step
         * further back to find the name of the encapsulating function from
         * which log() was called.
         */
        $file = isset($bt[$depth])     ? $bt[$depth]['file'] : null;
        $line = isset($bt[$depth])     ? $bt[$depth]['line'] : 0;
        $func = isset($bt[$depth + 1]) ? $bt[$depth + 1]['function'] : null;

        /*
         * However, if log() was called from one of our "shortcut" functions,
         * we're going to need to go back an additional step.
         */
        if (in_array($func, array('emerg', 'alert', 'crit', 'err', 'warning',
                                  'notice', 'info', 'debug'))) {
            $file = isset($bt[$depth + 1]) ? $bt[$depth + 1]['file'] : null;
            $line = isset($bt[$depth + 1]) ? $bt[$depth + 1]['line'] : 0;
            $func = isset($bt[$depth + 2]) ? $bt[$depth + 2]['function'] : null;
        }

        /*
         * If we couldn't extract a function name (perhaps because we were
         * executed from the "main" context), provide a default value.
         */
        if (is_null($func)) {
            $func = '(none)';
        }

        /* Return a 4-tuple containing (file, line, function, class). */
        return array($file, $line, $func, $class);
    }

    function _format($format, $timestamp, $priority, $message)
    {
        /*
         * If the format string references any of the backtrace-driven
         * variables (%5 %6,%7,%8), generate the backtrace and fetch them.
         */
        if (preg_match('/%[5678]/', $format)) {
            list($file, $line, $func, $class) = $this->_getBacktraceVars(2);
        }

        /*
         * Build the formatted string.  We use the sprintf() function's
         * "argument swapping" capability to dynamically select and position
         * the variables which will ultimately appear in the log string.
         */
        return sprintf($format,
                       $timestamp,
                       $this->_ident,
                       $this->priorityToString($priority),
                       $message,
                       isset($file) ? $file : '',
                       isset($line) ? $line : '',
                       isset($func) ? $func : '',
                       isset($class) ? $class : '');
    }

    function priorityToString($priority)
    {
        $levels = array(
            PEAR_LOG_EMERG   => 'emergency',
            PEAR_LOG_ALERT   => 'alert',
            PEAR_LOG_CRIT    => 'critical',
            PEAR_LOG_ERR     => 'error',
            PEAR_LOG_WARNING => 'warning',
            PEAR_LOG_NOTICE  => 'notice',
            PEAR_LOG_INFO    => 'info',
            PEAR_LOG_DEBUG   => 'debug'
        );

        return $levels[$priority];
    }

    function stringToPriority($name)
    {
        $levels = array(
            'emergency' => PEAR_LOG_EMERG,
            'alert'     => PEAR_LOG_ALERT,
            'critical'  => PEAR_LOG_CRIT,
            'error'     => PEAR_LOG_ERR,
            'warning'   => PEAR_LOG_WARNING,
            'notice'    => PEAR_LOG_NOTICE,
            'info'      => PEAR_LOG_INFO,
            'debug'     => PEAR_LOG_DEBUG
        );

        return $levels[strtolower($name)];
    }

    function MASK($priority)
    {
        return (1 << $priority);
    }

    function UPTO($priority)
    {
        return Log::MAX($priority);
    }

    function MIN($priority)
    {
        return PEAR_LOG_ALL ^ ((1 << $priority) - 1);
    }

    function MAX($priority)
    {
        return ((1 << ($priority + 1)) - 1);
    }

    function setMask($mask)
    {
        $this->_mask = $mask;

        return $this->_mask;
    }

    function getMask()
    {
        return $this->_mask;
    }

    function _isMasked($priority)
    {
        return (Log::MASK($priority) & $this->_mask);
    }

    function getPriority()
    {
        return $this->_priority;
    }

    function setPriority($priority)
    {
        $this->_priority = $priority;
    }

    function attach(&$observer)
    {
        if (!is_a($observer, 'Log_observer')) {
            return false;
        }

        $this->_listeners[$observer->_id] = &$observer;

        return true;
    }

    function detach($observer)
    {
        if (!is_a($observer, 'Log_observer') ||
            !isset($this->_listeners[$observer->_id])) {
            return false;
        }

        unset($this->_listeners[$observer->_id]);

        return true;
    }

    function _announce($event)
    {
        foreach ($this->_listeners as $id => $listener) {
            if ($event['priority'] <= $this->_listeners[$id]->_priority) {
                $this->_listeners[$id]->notify($event);
            }
        }
    }

    function isComposite()
    {
        return false;
    }

    function setIdent($ident)
    {
        $this->_ident = $ident;
    }

    function getIdent()
    {
        return $this->_ident;
    }
}