293 lines
7.6 KiB
PHP
293 lines
7.6 KiB
PHP
|
<?php
|
||
|
|
/**
|
||
|
|
* Logging.
|
||
|
|
*
|
||
|
|
* Log messages to text files.
|
||
|
|
*
|
||
|
|
* PHP versions 4 and 5
|
||
|
|
*
|
||
|
|
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
|
||
|
|
* Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org)
|
||
|
|
*
|
||
|
|
* Licensed under The MIT License
|
||
|
|
* Redistributions of files must retain the above copyright notice.
|
||
|
|
*
|
||
|
|
* @copyright Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org)
|
||
|
|
* @link http://cakephp.org CakePHP(tm) Project
|
||
|
|
* @package cake
|
||
|
|
* @subpackage cake.cake.libs
|
||
|
|
* @since CakePHP(tm) v 0.2.9
|
||
|
|
* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
|
||
|
|
*/
|
||
|
|
/**
|
||
|
|
* Set up error level constants to be used within the framework if they are not defined within the
|
||
|
|
* system.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
if (!defined('LOG_WARNING')) {
|
||
|
|
define('LOG_WARNING', 3);
|
||
|
|
}
|
||
|
|
if (!defined('LOG_NOTICE')) {
|
||
|
|
define('LOG_NOTICE', 4);
|
||
|
|
}
|
||
|
|
if (!defined('LOG_DEBUG')) {
|
||
|
|
define('LOG_DEBUG', 5);
|
||
|
|
}
|
||
|
|
if (!defined('LOG_INFO')) {
|
||
|
|
define('LOG_INFO', 6);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Logs messages to configured Log adapters. One or more adapters can be configured
|
||
|
|
* using CakeLogs's methods. If you don't configure any adapters, and write to the logs
|
||
|
|
* a default FileLog will be autoconfigured for you.
|
||
|
|
*
|
||
|
|
* @package cake
|
||
|
|
* @subpackage cake.cake.libs
|
||
|
|
*/
|
||
|
|
class CakeLog {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* An array of connected streams.
|
||
|
|
* Each stream represents a callable that will be called when write() is called.
|
||
|
|
*
|
||
|
|
* @var array
|
||
|
|
* @access protected
|
||
|
|
*/
|
||
|
|
var $_streams = array();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get an instance
|
||
|
|
*
|
||
|
|
* @return void
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
function &getInstance() {
|
||
|
|
static $instance = array();
|
||
|
|
if (!isset($instance[0])) {
|
||
|
|
$instance[0] =& new CakeLog();
|
||
|
|
}
|
||
|
|
return $instance[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Configure and add a new logging stream to CakeLog
|
||
|
|
* You can use add loggers from app/libs use app.loggername, or any plugin/libs using plugin.loggername.
|
||
|
|
*
|
||
|
|
* ### Usage:
|
||
|
|
*
|
||
|
|
* {{{
|
||
|
|
* CakeLog::config('second_file', array(
|
||
|
|
* 'engine' => 'FileLog',
|
||
|
|
* 'path' => '/var/logs/my_app/'
|
||
|
|
* ));
|
||
|
|
* }}}
|
||
|
|
*
|
||
|
|
* Will configure a FileLog instance to use the specified path. All options that are not `engine`
|
||
|
|
* are passed onto the logging adapter, and handled there. Any class can be configured as a logging
|
||
|
|
* adapter as long as it implements a `write` method with the following signature.
|
||
|
|
*
|
||
|
|
* `write($type, $message)`
|
||
|
|
*
|
||
|
|
* For an explaination of these parameters, see CakeLog::write()
|
||
|
|
*
|
||
|
|
* @param string $key The keyname for this logger, used to remove the logger later.
|
||
|
|
* @param array $config Array of configuration information for the logger
|
||
|
|
* @return boolean success of configuration.
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
function config($key, $config) {
|
||
|
|
if (empty($config['engine'])) {
|
||
|
|
trigger_error(__('Missing logger classname', true), E_USER_WARNING);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
$self =& CakeLog::getInstance();
|
||
|
|
$className = $self->_getLogger($config['engine']);
|
||
|
|
if (!$className) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
unset($config['engine']);
|
||
|
|
$self->_streams[$key] = new $className($config);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Attempts to import a logger class from the various paths it could be on.
|
||
|
|
* Checks that the logger class implements a write method as well.
|
||
|
|
*
|
||
|
|
* @param string $loggerName the plugin.className of the logger class you want to build.
|
||
|
|
* @return mixed boolean false on any failures, string of classname to use if search was successful.
|
||
|
|
* @access protected
|
||
|
|
*/
|
||
|
|
function _getLogger($loggerName) {
|
||
|
|
list($plugin, $loggerName) = pluginSplit($loggerName);
|
||
|
|
|
||
|
|
if ($plugin) {
|
||
|
|
App::import('Lib', $plugin . '.log/' . $loggerName);
|
||
|
|
} else {
|
||
|
|
if (!App::import('Lib', 'log/' . $loggerName)) {
|
||
|
|
App::import('Core', 'log/' . $loggerName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!class_exists($loggerName)) {
|
||
|
|
trigger_error(sprintf(__('Could not load logger class %s', true), $loggerName), E_USER_WARNING);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (!is_callable(array($loggerName, 'write'))) {
|
||
|
|
trigger_error(
|
||
|
|
sprintf(__('logger class %s does not implement a write method.', true), $loggerName),
|
||
|
|
E_USER_WARNING
|
||
|
|
);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return $loggerName;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the keynames of the currently active streams
|
||
|
|
*
|
||
|
|
* @return array Array of configured log streams.
|
||
|
|
* @access public
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
function configured() {
|
||
|
|
$self =& CakeLog::getInstance();
|
||
|
|
return array_keys($self->_streams);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Removes a stream from the active streams. Once a stream has been removed
|
||
|
|
* it will no longer have messages sent to it.
|
||
|
|
*
|
||
|
|
* @param string $keyname Key name of a configured stream to remove.
|
||
|
|
* @return void
|
||
|
|
* @access public
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
function drop($streamName) {
|
||
|
|
$self =& CakeLog::getInstance();
|
||
|
|
unset($self->_streams[$streamName]);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Configures the automatic/default stream a FileLog.
|
||
|
|
*
|
||
|
|
* @return void
|
||
|
|
* @access protected
|
||
|
|
*/
|
||
|
|
function _autoConfig() {
|
||
|
|
if (!class_exists('FileLog')) {
|
||
|
|
App::import('Core', 'log/FileLog');
|
||
|
|
}
|
||
|
|
$this->_streams['default'] =& new FileLog(array('path' => LOGS));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Writes the given message and type to all of the configured log adapters.
|
||
|
|
* Configured adapters are passed both the $type and $message variables. $type
|
||
|
|
* is one of the following strings/values.
|
||
|
|
*
|
||
|
|
* ### Types:
|
||
|
|
*
|
||
|
|
* - `LOG_WARNING` => 'warning',
|
||
|
|
* - `LOG_NOTICE` => 'notice',
|
||
|
|
* - `LOG_INFO` => 'info',
|
||
|
|
* - `LOG_DEBUG` => 'debug',
|
||
|
|
* - `LOG_ERR` => 'error',
|
||
|
|
* - `LOG_ERROR` => 'error'
|
||
|
|
*
|
||
|
|
* ### Usage:
|
||
|
|
*
|
||
|
|
* Write a message to the 'warning' log:
|
||
|
|
*
|
||
|
|
* `CakeLog::write('warning', 'Stuff is broken here');`
|
||
|
|
*
|
||
|
|
* @param string $type Type of message being written
|
||
|
|
* @param string $message Message content to log
|
||
|
|
* @return boolean Success
|
||
|
|
* @access public
|
||
|
|
* @static
|
||
|
|
*/
|
||
|
|
function write($type, $message) {
|
||
|
|
if (!defined('LOG_ERROR')) {
|
||
|
|
define('LOG_ERROR', 2);
|
||
|
|
}
|
||
|
|
if (!defined('LOG_ERR')) {
|
||
|
|
define('LOG_ERR', LOG_ERROR);
|
||
|
|
}
|
||
|
|
$levels = array(
|
||
|
|
LOG_WARNING => 'warning',
|
||
|
|
LOG_NOTICE => 'notice',
|
||
|
|
LOG_INFO => 'info',
|
||
|
|
LOG_DEBUG => 'debug',
|
||
|
|
LOG_ERR => 'error',
|
||
|
|
LOG_ERROR => 'error'
|
||
|
|
);
|
||
|
|
|
||
|
|
if (is_int($type) && isset($levels[$type])) {
|
||
|
|
$type = $levels[$type];
|
||
|
|
}
|
||
|
|
$self =& CakeLog::getInstance();
|
||
|
|
if (empty($self->_streams)) {
|
||
|
|
$self->_autoConfig();
|
||
|
|
}
|
||
|
|
$keys = array_keys($self->_streams);
|
||
|
|
foreach ($keys as $key) {
|
||
|
|
$logger =& $self->_streams[$key];
|
||
|
|
$logger->write($type, $message);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* An error_handler that will log errors to file using CakeLog::write();
|
||
|
|
* You can control how verbose and what type of errors this error_handler will
|
||
|
|
* catch using `Configure::write('log', $value)`. See core.php for more information.
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* @param integer $code Code of error
|
||
|
|
* @param string $description Error description
|
||
|
|
* @param string $file File on which error occurred
|
||
|
|
* @param integer $line Line that triggered the error
|
||
|
|
* @param array $context Context
|
||
|
|
* @return void
|
||
|
|
*/
|
||
|
|
function handleError($code, $description, $file = null, $line = null, $context = null) {
|
||
|
|
if ($code === 2048 || $code === 8192 || error_reporting() === 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
switch ($code) {
|
||
|
|
case E_PARSE:
|
||
|
|
case E_ERROR:
|
||
|
|
case E_CORE_ERROR:
|
||
|
|
case E_COMPILE_ERROR:
|
||
|
|
case E_USER_ERROR:
|
||
|
|
$error = 'Fatal Error';
|
||
|
|
$level = LOG_ERROR;
|
||
|
|
break;
|
||
|
|
case E_WARNING:
|
||
|
|
case E_USER_WARNING:
|
||
|
|
case E_COMPILE_WARNING:
|
||
|
|
case E_RECOVERABLE_ERROR:
|
||
|
|
$error = 'Warning';
|
||
|
|
$level = LOG_WARNING;
|
||
|
|
break;
|
||
|
|
case E_NOTICE:
|
||
|
|
case E_USER_NOTICE:
|
||
|
|
$error = 'Notice';
|
||
|
|
$level = LOG_NOTICE;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
return;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
$message = $error . ' (' . $code . '): ' . $description . ' in [' . $file . ', line ' . $line . ']';
|
||
|
|
CakeLog::write($level, $message);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!defined('DISABLE_DEFAULT_ERROR_HANDLING')) {
|
||
|
|
$cakeLog =& CakeLog::getInstance();
|
||
|
|
set_error_handler(array($cakeLog, 'handleError'));
|
||
|
|
}
|