979 lines
33 KiB
PHP
979 lines
33 KiB
PHP
<?php
|
|
/**
|
|
* Error Stack Implementation
|
|
*
|
|
* This is an incredibly simple implementation of a very complex error handling
|
|
* facility. It contains the ability
|
|
* to track multiple errors from multiple packages simultaneously. In addition,
|
|
* it can track errors of many levels, save data along with the error, context
|
|
* information such as the exact file, line number, class and function that
|
|
* generated the error, and if necessary, it can raise a traditional PEAR_Error.
|
|
* It has built-in support for PEAR::Log, to log errors as they occur
|
|
*
|
|
* Since version 0.2alpha, it is also possible to selectively ignore errors,
|
|
* through the use of an error callback, see {@link pushCallback()}
|
|
*
|
|
* Since version 0.3alpha, it is possible to specify the exception class
|
|
* returned from {@link push()}
|
|
*
|
|
* Since version PEAR1.3.2, ErrorStack no longer instantiates an exception class. This can
|
|
* still be done quite handily in an error callback or by manipulating the returned array
|
|
* @category Debugging
|
|
* @package PEAR_ErrorStack
|
|
* @author Greg Beaver <cellog@php.net>
|
|
* @copyright 2004-2008 Greg Beaver
|
|
* @license http://opensource.org/licenses/bsd-license.php New BSD License
|
|
* @link http://pear.php.net/package/PEAR_ErrorStack
|
|
*/
|
|
|
|
/**
|
|
* Singleton storage
|
|
*
|
|
* Format:
|
|
* <pre>
|
|
* array(
|
|
* 'package1' => PEAR_ErrorStack object,
|
|
* 'package2' => PEAR_ErrorStack object,
|
|
* ...
|
|
* )
|
|
* </pre>
|
|
* @access private
|
|
* @global array $GLOBALS['_PEAR_ERRORSTACK_SINGLETON']
|
|
*/
|
|
$GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] = array();
|
|
|
|
/**
|
|
* Global error callback (default)
|
|
*
|
|
* This is only used if set to non-false. * is the default callback for
|
|
* all packages, whereas specific packages may set a default callback
|
|
* for all instances, regardless of whether they are a singleton or not.
|
|
*
|
|
* To exclude non-singletons, only set the local callback for the singleton
|
|
* @see PEAR_ErrorStack::setDefaultCallback()
|
|
* @access private
|
|
* @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK']
|
|
*/
|
|
$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'] = array(
|
|
'*' => false,
|
|
);
|
|
|
|
/**
|
|
* Global Log object (default)
|
|
*
|
|
* This is only used if set to non-false. Use to set a default log object for
|
|
* all stacks, regardless of instantiation order or location
|
|
* @see PEAR_ErrorStack::setDefaultLogger()
|
|
* @access private
|
|
* @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']
|
|
*/
|
|
$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = false;
|
|
|
|
/**
|
|
* Global Overriding Callback
|
|
*
|
|
* This callback will override any error callbacks that specific loggers have set.
|
|
* Use with EXTREME caution
|
|
* @see PEAR_ErrorStack::staticPushCallback()
|
|
* @access private
|
|
* @global array $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']
|
|
*/
|
|
$GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();
|
|
|
|
/**#@+
|
|
* One of four possible return values from the error Callback
|
|
* @see PEAR_ErrorStack::_errorCallback()
|
|
*/
|
|
/**
|
|
* If this is returned, then the error will be both pushed onto the stack
|
|
* and logged.
|
|
*/
|
|
define('PEAR_ERRORSTACK_PUSHANDLOG', 1);
|
|
/**
|
|
* If this is returned, then the error will only be pushed onto the stack,
|
|
* and not logged.
|
|
*/
|
|
define('PEAR_ERRORSTACK_PUSH', 2);
|
|
/**
|
|
* If this is returned, then the error will only be logged, but not pushed
|
|
* onto the error stack.
|
|
*/
|
|
define('PEAR_ERRORSTACK_LOG', 3);
|
|
/**
|
|
* If this is returned, then the error is completely ignored.
|
|
*/
|
|
define('PEAR_ERRORSTACK_IGNORE', 4);
|
|
/**
|
|
* If this is returned, then the error is logged and die() is called.
|
|
*/
|
|
define('PEAR_ERRORSTACK_DIE', 5);
|
|
/**#@-*/
|
|
|
|
/**
|
|
* Error code for an attempt to instantiate a non-class as a PEAR_ErrorStack in
|
|
* the singleton method.
|
|
*/
|
|
define('PEAR_ERRORSTACK_ERR_NONCLASS', 1);
|
|
|
|
/**
|
|
* Error code for an attempt to pass an object into {@link PEAR_ErrorStack::getMessage()}
|
|
* that has no __toString() method
|
|
*/
|
|
define('PEAR_ERRORSTACK_ERR_OBJTOSTRING', 2);
|
|
/**
|
|
* Error Stack Implementation
|
|
*
|
|
* Usage:
|
|
* <code>
|
|
* // global error stack
|
|
* $global_stack = &PEAR_ErrorStack::singleton('MyPackage');
|
|
* // local error stack
|
|
* $local_stack = new PEAR_ErrorStack('MyPackage');
|
|
* </code>
|
|
* @author Greg Beaver <cellog@php.net>
|
|
* @version 1.10.4
|
|
* @package PEAR_ErrorStack
|
|
* @category Debugging
|
|
* @copyright 2004-2008 Greg Beaver
|
|
* @license http://opensource.org/licenses/bsd-license.php New BSD License
|
|
* @link http://pear.php.net/package/PEAR_ErrorStack
|
|
*/
|
|
class PEAR_ErrorStack {
|
|
/**
|
|
* Errors are stored in the order that they are pushed on the stack.
|
|
* @since 0.4alpha Errors are no longer organized by error level.
|
|
* This renders pop() nearly unusable, and levels could be more easily
|
|
* handled in a callback anyway
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
var $_errors = array();
|
|
|
|
/**
|
|
* Storage of errors by level.
|
|
*
|
|
* Allows easy retrieval and deletion of only errors from a particular level
|
|
* @since PEAR 1.4.0dev
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
var $_errorsByLevel = array();
|
|
|
|
/**
|
|
* Package name this error stack represents
|
|
* @var string
|
|
* @access protected
|
|
*/
|
|
var $_package;
|
|
|
|
/**
|
|
* Determines whether a PEAR_Error is thrown upon every error addition
|
|
* @var boolean
|
|
* @access private
|
|
*/
|
|
var $_compat = false;
|
|
|
|
/**
|
|
* If set to a valid callback, this will be used to generate the error
|
|
* message from the error code, otherwise the message passed in will be
|
|
* used
|
|
* @var false|string|array
|
|
* @access private
|
|
*/
|
|
var $_msgCallback = false;
|
|
|
|
/**
|
|
* If set to a valid callback, this will be used to generate the error
|
|
* context for an error. For PHP-related errors, this will be a file
|
|
* and line number as retrieved from debug_backtrace(), but can be
|
|
* customized for other purposes. The error might actually be in a separate
|
|
* configuration file, or in a database query.
|
|
* @var false|string|array
|
|
* @access protected
|
|
*/
|
|
var $_contextCallback = false;
|
|
|
|
/**
|
|
* If set to a valid callback, this will be called every time an error
|
|
* is pushed onto the stack. The return value will be used to determine
|
|
* whether to allow an error to be pushed or logged.
|
|
*
|
|
* The return value must be one an PEAR_ERRORSTACK_* constant
|
|
* @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG
|
|
* @var false|string|array
|
|
* @access protected
|
|
*/
|
|
var $_errorCallback = array();
|
|
|
|
/**
|
|
* PEAR::Log object for logging errors
|
|
* @var false|Log
|
|
* @access protected
|
|
*/
|
|
var $_logger = false;
|
|
|
|
/**
|
|
* Error messages - designed to be overridden
|
|
* @var array
|
|
* @abstract
|
|
*/
|
|
var $_errorMsgs = array();
|
|
|
|
/**
|
|
* Set up a new error stack
|
|
*
|
|
* @param string $package name of the package this error stack represents
|
|
* @param callback $msgCallback callback used for error message generation
|
|
* @param callback $contextCallback callback used for context generation,
|
|
* defaults to {@link getFileLine()}
|
|
* @param boolean $throwPEAR_Error
|
|
*/
|
|
function __construct($package, $msgCallback = false, $contextCallback = false,
|
|
$throwPEAR_Error = false)
|
|
{
|
|
$this->_package = $package;
|
|
$this->setMessageCallback($msgCallback);
|
|
$this->setContextCallback($contextCallback);
|
|
$this->_compat = $throwPEAR_Error;
|
|
}
|
|
|
|
/**
|
|
* Return a single error stack for this package.
|
|
*
|
|
* Note that all parameters are ignored if the stack for package $package
|
|
* has already been instantiated
|
|
* @param string $package name of the package this error stack represents
|
|
* @param callback $msgCallback callback used for error message generation
|
|
* @param callback $contextCallback callback used for context generation,
|
|
* defaults to {@link getFileLine()}
|
|
* @param boolean $throwPEAR_Error
|
|
* @param string $stackClass class to instantiate
|
|
*
|
|
* @return PEAR_ErrorStack
|
|
*/
|
|
public static function &singleton(
|
|
$package, $msgCallback = false, $contextCallback = false,
|
|
$throwPEAR_Error = false, $stackClass = 'PEAR_ErrorStack'
|
|
) {
|
|
if (isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
|
|
return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];
|
|
}
|
|
if (!class_exists($stackClass)) {
|
|
if (function_exists('debug_backtrace')) {
|
|
$trace = debug_backtrace();
|
|
}
|
|
PEAR_ErrorStack::staticPush('PEAR_ErrorStack', PEAR_ERRORSTACK_ERR_NONCLASS,
|
|
'exception', array('stackclass' => $stackClass),
|
|
'stack class "%stackclass%" is not a valid class name (should be like PEAR_ErrorStack)',
|
|
false, $trace);
|
|
}
|
|
$GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package] =
|
|
new $stackClass($package, $msgCallback, $contextCallback, $throwPEAR_Error);
|
|
|
|
return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package];
|
|
}
|
|
|
|
/**
|
|
* Internal error handler for PEAR_ErrorStack class
|
|
*
|
|
* Dies if the error is an exception (and would have died anyway)
|
|
* @access private
|
|
*/
|
|
function _handleError($err)
|
|
{
|
|
if ($err['level'] == 'exception') {
|
|
$message = $err['message'];
|
|
if (isset($_SERVER['REQUEST_URI'])) {
|
|
echo '<br />';
|
|
} else {
|
|
echo "\n";
|
|
}
|
|
var_dump($err['context']);
|
|
die($message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set up a PEAR::Log object for all error stacks that don't have one
|
|
* @param Log $log
|
|
*/
|
|
public static function setDefaultLogger(&$log)
|
|
{
|
|
if (is_object($log) && method_exists($log, 'log') ) {
|
|
$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;
|
|
} elseif (is_callable($log)) {
|
|
$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'] = &$log;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set up a PEAR::Log object for this error stack
|
|
* @param Log $log
|
|
*/
|
|
function setLogger(&$log)
|
|
{
|
|
if (is_object($log) && method_exists($log, 'log') ) {
|
|
$this->_logger = &$log;
|
|
} elseif (is_callable($log)) {
|
|
$this->_logger = &$log;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set an error code => error message mapping callback
|
|
*
|
|
* This method sets the callback that can be used to generate error
|
|
* messages for any instance
|
|
* @param array|string Callback function/method
|
|
*/
|
|
function setMessageCallback($msgCallback)
|
|
{
|
|
if (!$msgCallback) {
|
|
$this->_msgCallback = array(&$this, 'getErrorMessage');
|
|
} else {
|
|
if (is_callable($msgCallback)) {
|
|
$this->_msgCallback = $msgCallback;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get an error code => error message mapping callback
|
|
*
|
|
* This method returns the current callback that can be used to generate error
|
|
* messages
|
|
* @return array|string|false Callback function/method or false if none
|
|
*/
|
|
function getMessageCallback()
|
|
{
|
|
return $this->_msgCallback;
|
|
}
|
|
|
|
/**
|
|
* Sets a default callback to be used by all error stacks
|
|
*
|
|
* This method sets the callback that can be used to generate error
|
|
* messages for a singleton
|
|
* @param array|string Callback function/method
|
|
* @param string Package name, or false for all packages
|
|
*/
|
|
public static function setDefaultCallback($callback = false, $package = false)
|
|
{
|
|
if (!is_callable($callback)) {
|
|
$callback = false;
|
|
}
|
|
$package = $package ? $package : '*';
|
|
$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$package] = $callback;
|
|
}
|
|
|
|
/**
|
|
* Set a callback that generates context information (location of error) for an error stack
|
|
*
|
|
* This method sets the callback that can be used to generate context
|
|
* information for an error. Passing in NULL will disable context generation
|
|
* and remove the expensive call to debug_backtrace()
|
|
* @param array|string|null Callback function/method
|
|
*/
|
|
function setContextCallback($contextCallback)
|
|
{
|
|
if ($contextCallback === null) {
|
|
return $this->_contextCallback = false;
|
|
}
|
|
if (!$contextCallback) {
|
|
$this->_contextCallback = array(&$this, 'getFileLine');
|
|
} else {
|
|
if (is_callable($contextCallback)) {
|
|
$this->_contextCallback = $contextCallback;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set an error Callback
|
|
* If set to a valid callback, this will be called every time an error
|
|
* is pushed onto the stack. The return value will be used to determine
|
|
* whether to allow an error to be pushed or logged.
|
|
*
|
|
* The return value must be one of the ERRORSTACK_* constants.
|
|
*
|
|
* This functionality can be used to emulate PEAR's pushErrorHandling, and
|
|
* the PEAR_ERROR_CALLBACK mode, without affecting the integrity of
|
|
* the error stack or logging
|
|
* @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG
|
|
* @see popCallback()
|
|
* @param string|array $cb
|
|
*/
|
|
function pushCallback($cb)
|
|
{
|
|
array_push($this->_errorCallback, $cb);
|
|
}
|
|
|
|
/**
|
|
* Remove a callback from the error callback stack
|
|
* @see pushCallback()
|
|
* @return array|string|false
|
|
*/
|
|
function popCallback()
|
|
{
|
|
if (!count($this->_errorCallback)) {
|
|
return false;
|
|
}
|
|
return array_pop($this->_errorCallback);
|
|
}
|
|
|
|
/**
|
|
* Set a temporary overriding error callback for every package error stack
|
|
*
|
|
* Use this to temporarily disable all existing callbacks (can be used
|
|
* to emulate the @ operator, for instance)
|
|
* @see PEAR_ERRORSTACK_PUSHANDLOG, PEAR_ERRORSTACK_PUSH, PEAR_ERRORSTACK_LOG
|
|
* @see staticPopCallback(), pushCallback()
|
|
* @param string|array $cb
|
|
*/
|
|
public static function staticPushCallback($cb)
|
|
{
|
|
array_push($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'], $cb);
|
|
}
|
|
|
|
/**
|
|
* Remove a temporary overriding error callback
|
|
* @see staticPushCallback()
|
|
* @return array|string|false
|
|
*/
|
|
public static function staticPopCallback()
|
|
{
|
|
$ret = array_pop($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK']);
|
|
if (!is_array($GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'])) {
|
|
$GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Add an error to the stack
|
|
*
|
|
* If the message generator exists, it is called with 2 parameters.
|
|
* - the current Error Stack object
|
|
* - an array that is in the same format as an error. Available indices
|
|
* are 'code', 'package', 'time', 'params', 'level', and 'context'
|
|
*
|
|
* Next, if the error should contain context information, this is
|
|
* handled by the context grabbing method.
|
|
* Finally, the error is pushed onto the proper error stack
|
|
* @param int $code Package-specific error code
|
|
* @param string $level Error level. This is NOT spell-checked
|
|
* @param array $params associative array of error parameters
|
|
* @param string $msg Error message, or a portion of it if the message
|
|
* is to be generated
|
|
* @param array $repackage If this error re-packages an error pushed by
|
|
* another package, place the array returned from
|
|
* {@link pop()} in this parameter
|
|
* @param array $backtrace Protected parameter: use this to pass in the
|
|
* {@link debug_backtrace()} that should be used
|
|
* to find error context
|
|
* @return PEAR_Error|array if compatibility mode is on, a PEAR_Error is also
|
|
* thrown. If a PEAR_Error is returned, the userinfo
|
|
* property is set to the following array:
|
|
*
|
|
* <code>
|
|
* array(
|
|
* 'code' => $code,
|
|
* 'params' => $params,
|
|
* 'package' => $this->_package,
|
|
* 'level' => $level,
|
|
* 'time' => time(),
|
|
* 'context' => $context,
|
|
* 'message' => $msg,
|
|
* //['repackage' => $err] repackaged error array/Exception class
|
|
* );
|
|
* </code>
|
|
*
|
|
* Normally, the previous array is returned.
|
|
*/
|
|
function push($code, $level = 'error', $params = array(), $msg = false,
|
|
$repackage = false, $backtrace = false)
|
|
{
|
|
$context = false;
|
|
// grab error context
|
|
if ($this->_contextCallback) {
|
|
if (!$backtrace) {
|
|
$backtrace = debug_backtrace();
|
|
}
|
|
$context = call_user_func($this->_contextCallback, $code, $params, $backtrace);
|
|
}
|
|
|
|
// save error
|
|
$time = explode(' ', microtime());
|
|
$time = $time[1] + $time[0];
|
|
$err = array(
|
|
'code' => $code,
|
|
'params' => $params,
|
|
'package' => $this->_package,
|
|
'level' => $level,
|
|
'time' => $time,
|
|
'context' => $context,
|
|
'message' => $msg,
|
|
);
|
|
|
|
if ($repackage) {
|
|
$err['repackage'] = $repackage;
|
|
}
|
|
|
|
// set up the error message, if necessary
|
|
if ($this->_msgCallback) {
|
|
$msg = call_user_func_array($this->_msgCallback,
|
|
array(&$this, $err));
|
|
$err['message'] = $msg;
|
|
}
|
|
$push = $log = true;
|
|
$die = false;
|
|
// try the overriding callback first
|
|
$callback = $this->staticPopCallback();
|
|
if ($callback) {
|
|
$this->staticPushCallback($callback);
|
|
}
|
|
if (!is_callable($callback)) {
|
|
// try the local callback next
|
|
$callback = $this->popCallback();
|
|
if (is_callable($callback)) {
|
|
$this->pushCallback($callback);
|
|
} else {
|
|
// try the default callback
|
|
$callback = isset($GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$this->_package]) ?
|
|
$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK'][$this->_package] :
|
|
$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_CALLBACK']['*'];
|
|
}
|
|
}
|
|
if (is_callable($callback)) {
|
|
switch(call_user_func($callback, $err)){
|
|
case PEAR_ERRORSTACK_IGNORE:
|
|
return $err;
|
|
break;
|
|
case PEAR_ERRORSTACK_PUSH:
|
|
$log = false;
|
|
break;
|
|
case PEAR_ERRORSTACK_LOG:
|
|
$push = false;
|
|
break;
|
|
case PEAR_ERRORSTACK_DIE:
|
|
$die = true;
|
|
break;
|
|
// anything else returned has the same effect as pushandlog
|
|
}
|
|
}
|
|
if ($push) {
|
|
array_unshift($this->_errors, $err);
|
|
if (!isset($this->_errorsByLevel[$err['level']])) {
|
|
$this->_errorsByLevel[$err['level']] = array();
|
|
}
|
|
$this->_errorsByLevel[$err['level']][] = &$this->_errors[0];
|
|
}
|
|
if ($log) {
|
|
if ($this->_logger || $GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER']) {
|
|
$this->_log($err);
|
|
}
|
|
}
|
|
if ($die) {
|
|
die();
|
|
}
|
|
if ($this->_compat && $push) {
|
|
return $this->raiseError($msg, $code, null, null, $err);
|
|
}
|
|
return $err;
|
|
}
|
|
|
|
/**
|
|
* Static version of {@link push()}
|
|
*
|
|
* @param string $package Package name this error belongs to
|
|
* @param int $code Package-specific error code
|
|
* @param string $level Error level. This is NOT spell-checked
|
|
* @param array $params associative array of error parameters
|
|
* @param string $msg Error message, or a portion of it if the message
|
|
* is to be generated
|
|
* @param array $repackage If this error re-packages an error pushed by
|
|
* another package, place the array returned from
|
|
* {@link pop()} in this parameter
|
|
* @param array $backtrace Protected parameter: use this to pass in the
|
|
* {@link debug_backtrace()} that should be used
|
|
* to find error context
|
|
* @return PEAR_Error|array if compatibility mode is on, a PEAR_Error is also
|
|
* thrown. see docs for {@link push()}
|
|
*/
|
|
public static function staticPush(
|
|
$package, $code, $level = 'error', $params = array(),
|
|
$msg = false, $repackage = false, $backtrace = false
|
|
) {
|
|
$s = &PEAR_ErrorStack::singleton($package);
|
|
if ($s->_contextCallback) {
|
|
if (!$backtrace) {
|
|
if (function_exists('debug_backtrace')) {
|
|
$backtrace = debug_backtrace();
|
|
}
|
|
}
|
|
}
|
|
return $s->push($code, $level, $params, $msg, $repackage, $backtrace);
|
|
}
|
|
|
|
/**
|
|
* Log an error using PEAR::Log
|
|
* @param array $err Error array
|
|
* @param array $levels Error level => Log constant map
|
|
* @access protected
|
|
*/
|
|
function _log($err)
|
|
{
|
|
if ($this->_logger) {
|
|
$logger = &$this->_logger;
|
|
} else {
|
|
$logger = &$GLOBALS['_PEAR_ERRORSTACK_DEFAULT_LOGGER'];
|
|
}
|
|
if (is_a($logger, 'Log')) {
|
|
$levels = array(
|
|
'exception' => PEAR_LOG_CRIT,
|
|
'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);
|
|
if (isset($levels[$err['level']])) {
|
|
$level = $levels[$err['level']];
|
|
} else {
|
|
$level = PEAR_LOG_INFO;
|
|
}
|
|
$logger->log($err['message'], $level, $err);
|
|
} else { // support non-standard logs
|
|
call_user_func($logger, $err);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Pop an error off of the error stack
|
|
*
|
|
* @return false|array
|
|
* @since 0.4alpha it is no longer possible to specify a specific error
|
|
* level to return - the last error pushed will be returned, instead
|
|
*/
|
|
function pop()
|
|
{
|
|
$err = @array_shift($this->_errors);
|
|
if (!is_null($err)) {
|
|
@array_pop($this->_errorsByLevel[$err['level']]);
|
|
if (!count($this->_errorsByLevel[$err['level']])) {
|
|
unset($this->_errorsByLevel[$err['level']]);
|
|
}
|
|
}
|
|
return $err;
|
|
}
|
|
|
|
/**
|
|
* Pop an error off of the error stack, static method
|
|
*
|
|
* @param string package name
|
|
* @return boolean
|
|
* @since PEAR1.5.0a1
|
|
*/
|
|
function staticPop($package)
|
|
{
|
|
if ($package) {
|
|
if (!isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
|
|
return false;
|
|
}
|
|
return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->pop();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine whether there are any errors on the stack
|
|
* @param string|array Level name. Use to determine if any errors
|
|
* of level (string), or levels (array) have been pushed
|
|
* @return boolean
|
|
*/
|
|
function hasErrors($level = false)
|
|
{
|
|
if ($level) {
|
|
return isset($this->_errorsByLevel[$level]);
|
|
}
|
|
return count($this->_errors);
|
|
}
|
|
|
|
/**
|
|
* Retrieve all errors since last purge
|
|
*
|
|
* @param boolean set in order to empty the error stack
|
|
* @param string level name, to return only errors of a particular severity
|
|
* @return array
|
|
*/
|
|
function getErrors($purge = false, $level = false)
|
|
{
|
|
if (!$purge) {
|
|
if ($level) {
|
|
if (!isset($this->_errorsByLevel[$level])) {
|
|
return array();
|
|
} else {
|
|
return $this->_errorsByLevel[$level];
|
|
}
|
|
} else {
|
|
return $this->_errors;
|
|
}
|
|
}
|
|
if ($level) {
|
|
$ret = $this->_errorsByLevel[$level];
|
|
foreach ($this->_errorsByLevel[$level] as $i => $unused) {
|
|
// entries are references to the $_errors array
|
|
$this->_errorsByLevel[$level][$i] = false;
|
|
}
|
|
// array_filter removes all entries === false
|
|
$this->_errors = array_filter($this->_errors);
|
|
unset($this->_errorsByLevel[$level]);
|
|
return $ret;
|
|
}
|
|
$ret = $this->_errors;
|
|
$this->_errors = array();
|
|
$this->_errorsByLevel = array();
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Determine whether there are any errors on a single error stack, or on any error stack
|
|
*
|
|
* The optional parameter can be used to test the existence of any errors without the need of
|
|
* singleton instantiation
|
|
* @param string|false Package name to check for errors
|
|
* @param string Level name to check for a particular severity
|
|
* @return boolean
|
|
*/
|
|
public static function staticHasErrors($package = false, $level = false)
|
|
{
|
|
if ($package) {
|
|
if (!isset($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package])) {
|
|
return false;
|
|
}
|
|
return $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->hasErrors($level);
|
|
}
|
|
foreach ($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] as $package => $obj) {
|
|
if ($obj->hasErrors($level)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get a list of all errors since last purge, organized by package
|
|
* @since PEAR 1.4.0dev BC break! $level is now in the place $merge used to be
|
|
* @param boolean $purge Set to purge the error stack of existing errors
|
|
* @param string $level Set to a level name in order to retrieve only errors of a particular level
|
|
* @param boolean $merge Set to return a flat array, not organized by package
|
|
* @param array $sortfunc Function used to sort a merged array - default
|
|
* sorts by time, and should be good for most cases
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function staticGetErrors(
|
|
$purge = false, $level = false, $merge = false,
|
|
$sortfunc = array('PEAR_ErrorStack', '_sortErrors')
|
|
) {
|
|
$ret = array();
|
|
if (!is_callable($sortfunc)) {
|
|
$sortfunc = array('PEAR_ErrorStack', '_sortErrors');
|
|
}
|
|
foreach ($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] as $package => $obj) {
|
|
$test = $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->getErrors($purge, $level);
|
|
if ($test) {
|
|
if ($merge) {
|
|
$ret = array_merge($ret, $test);
|
|
} else {
|
|
$ret[$package] = $test;
|
|
}
|
|
}
|
|
}
|
|
if ($merge) {
|
|
usort($ret, $sortfunc);
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Error sorting function, sorts by time
|
|
* @access private
|
|
*/
|
|
public static function _sortErrors($a, $b)
|
|
{
|
|
if ($a['time'] == $b['time']) {
|
|
return 0;
|
|
}
|
|
if ($a['time'] < $b['time']) {
|
|
return 1;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Standard file/line number/function/class context callback
|
|
*
|
|
* This function uses a backtrace generated from {@link debug_backtrace()}
|
|
* and so will not work at all in PHP < 4.3.0. The frame should
|
|
* reference the frame that contains the source of the error.
|
|
* @return array|false either array('file' => file, 'line' => line,
|
|
* 'function' => function name, 'class' => class name) or
|
|
* if this doesn't work, then false
|
|
* @param unused
|
|
* @param integer backtrace frame.
|
|
* @param array Results of debug_backtrace()
|
|
*/
|
|
public static function getFileLine($code, $params, $backtrace = null)
|
|
{
|
|
if ($backtrace === null) {
|
|
return false;
|
|
}
|
|
$frame = 0;
|
|
$functionframe = 1;
|
|
if (!isset($backtrace[1])) {
|
|
$functionframe = 0;
|
|
} else {
|
|
while (isset($backtrace[$functionframe]['function']) &&
|
|
$backtrace[$functionframe]['function'] == 'eval' &&
|
|
isset($backtrace[$functionframe + 1])) {
|
|
$functionframe++;
|
|
}
|
|
}
|
|
if (isset($backtrace[$frame])) {
|
|
if (!isset($backtrace[$frame]['file'])) {
|
|
$frame++;
|
|
}
|
|
$funcbacktrace = $backtrace[$functionframe];
|
|
$filebacktrace = $backtrace[$frame];
|
|
$ret = array('file' => $filebacktrace['file'],
|
|
'line' => $filebacktrace['line']);
|
|
// rearrange for eval'd code or create function errors
|
|
if (strpos($filebacktrace['file'], '(') &&
|
|
preg_match(';^(.*?)\((\d+)\) : (.*?)\\z;', $filebacktrace['file'],
|
|
$matches)) {
|
|
$ret['file'] = $matches[1];
|
|
$ret['line'] = $matches[2] + 0;
|
|
}
|
|
if (isset($funcbacktrace['function']) && isset($backtrace[1])) {
|
|
if ($funcbacktrace['function'] != 'eval') {
|
|
if ($funcbacktrace['function'] == '__lambda_func') {
|
|
$ret['function'] = 'create_function() code';
|
|
} else {
|
|
$ret['function'] = $funcbacktrace['function'];
|
|
}
|
|
}
|
|
}
|
|
if (isset($funcbacktrace['class']) && isset($backtrace[1])) {
|
|
$ret['class'] = $funcbacktrace['class'];
|
|
}
|
|
return $ret;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Standard error message generation callback
|
|
*
|
|
* This method may also be called by a custom error message generator
|
|
* to fill in template values from the params array, simply
|
|
* set the third parameter to the error message template string to use
|
|
*
|
|
* The special variable %__msg% is reserved: use it only to specify
|
|
* where a message passed in by the user should be placed in the template,
|
|
* like so:
|
|
*
|
|
* Error message: %msg% - internal error
|
|
*
|
|
* If the message passed like so:
|
|
*
|
|
* <code>
|
|
* $stack->push(ERROR_CODE, 'error', array(), 'server error 500');
|
|
* </code>
|
|
*
|
|
* The returned error message will be "Error message: server error 500 -
|
|
* internal error"
|
|
* @param PEAR_ErrorStack
|
|
* @param array
|
|
* @param string|false Pre-generated error message template
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getErrorMessage(&$stack, $err, $template = false)
|
|
{
|
|
if ($template) {
|
|
$mainmsg = $template;
|
|
} else {
|
|
$mainmsg = $stack->getErrorMessageTemplate($err['code']);
|
|
}
|
|
$mainmsg = str_replace('%__msg%', $err['message'], $mainmsg);
|
|
if (is_array($err['params']) && count($err['params'])) {
|
|
foreach ($err['params'] as $name => $val) {
|
|
if (is_array($val)) {
|
|
// @ is needed in case $val is a multi-dimensional array
|
|
$val = @implode(', ', $val);
|
|
}
|
|
if (is_object($val)) {
|
|
if (method_exists($val, '__toString')) {
|
|
$val = $val->__toString();
|
|
} else {
|
|
PEAR_ErrorStack::staticPush('PEAR_ErrorStack', PEAR_ERRORSTACK_ERR_OBJTOSTRING,
|
|
'warning', array('obj' => get_class($val)),
|
|
'object %obj% passed into getErrorMessage, but has no __toString() method');
|
|
$val = 'Object';
|
|
}
|
|
}
|
|
$mainmsg = str_replace('%' . $name . '%', $val, $mainmsg);
|
|
}
|
|
}
|
|
return $mainmsg;
|
|
}
|
|
|
|
/**
|
|
* Standard Error Message Template generator from code
|
|
* @return string
|
|
*/
|
|
function getErrorMessageTemplate($code)
|
|
{
|
|
if (!isset($this->_errorMsgs[$code])) {
|
|
return '%__msg%';
|
|
}
|
|
return $this->_errorMsgs[$code];
|
|
}
|
|
|
|
/**
|
|
* Set the Error Message Template array
|
|
*
|
|
* The array format must be:
|
|
* <pre>
|
|
* array(error code => 'message template',...)
|
|
* </pre>
|
|
*
|
|
* Error message parameters passed into {@link push()} will be used as input
|
|
* for the error message. If the template is 'message %foo% was %bar%', and the
|
|
* parameters are array('foo' => 'one', 'bar' => 'six'), the error message returned will
|
|
* be 'message one was six'
|
|
* @return string
|
|
*/
|
|
function setErrorMessageTemplate($template)
|
|
{
|
|
$this->_errorMsgs = $template;
|
|
}
|
|
|
|
|
|
/**
|
|
* emulate PEAR::raiseError()
|
|
*
|
|
* @return PEAR_Error
|
|
*/
|
|
function raiseError()
|
|
{
|
|
require_once 'PEAR.php';
|
|
$args = func_get_args();
|
|
return call_user_func_array(array('PEAR', 'raiseError'), $args);
|
|
}
|
|
}
|
|
$stack = &PEAR_ErrorStack::singleton('PEAR_ErrorStack');
|
|
$stack->pushCallback(array('PEAR_ErrorStack', '_handleError'));
|
|
?>
|