brmlab/brmsklad
4
0
Fork 0
mirror of https://github.com/brmlab/brmsklad.git synced 2025-08-02 14:23:34 +02:00
Code Issues Projects Releases Packages Wiki Activity

Upgrade CakePHP from 2.2.5 to 2.9.5

Browse source
This commit is contained in:
Brm Ko 2017-02-26 15:29:44 +01:00
parent 5a580df460
commit 235a541597
793 changed files with 60746 additions and 23753 deletions
Download patch file Download diff file Expand all files Collapse all files

245
lib/Cake/Log/CakeLog.php
View file

@ -4,43 +4,42 @@
*
* Log messages to text files.
*
* PHP 5
*
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
* Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @copyright Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://cakephp.org CakePHP(tm) Project
* @package Cake.Log
* @since CakePHP(tm) v 0.2.9
* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('LogEngineCollection', 'Log');
/**
* 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.
* Logs messages to configured Log adapters.
*
* One or more adapters
* can be configured using CakeLogs's methods.
*
* ### Configuring Log adapters
*
* You can configure log adapters in your applications `bootstrap.php` file.
* A sample configuration would look like:
*
* {{{
* CakeLog::config('my_log', array('engine' => 'FileLog'));
* }}}
* ```
* CakeLog::config('my_log', array('engine' => 'File'));
* ```
*
* See the documentation on CakeLog::config() for more detail.
*
* ### Writing to the log
*
* You write to the logs using CakeLog::write(). See its documentation for more
* You write to the logs using CakeLog::write(). See its documentation for more
* information.
*
* ### Logging Levels
@ -49,29 +48,29 @@ App::uses('LogEngineCollection', 'Log');
* RFC 5424. When logging messages you can either use the named methods,
* or the correct constants with `write()`:
*
* {{{
* ```
* CakeLog::error('Something horrible happened');
* CakeLog::write(LOG_ERR, 'Something horrible happened');
* }}}
* ```
*
* If you require custom logging levels, you can use CakeLog::levels() to
* append additoinal logging levels.
* append additional logging levels.
*
* ### Logging scopes
*
* When logging messages and configuring log adapters, you can specify
* 'scopes' that the logger will handle. You can think of scopes as subsystems
* in your application that may require different logging setups. For
* 'scopes' that the logger will handle. You can think of scopes as subsystems
* in your application that may require different logging setups. For
* example in an e-commerce application you may want to handle logged errors
* in the cart and ordering subsystems differently than the rest of the
* application. By using scopes you can control logging for each part
* application. By using scopes you can control logging for each part
* of your application and still keep standard log levels.
*
*
* See CakeLog::config() and CakeLog::write() for more information
* on scopes
*
* @package Cake.Log
* @link http://book.cakephp.org/2.0/en/core-libraries/logging.html#logging
*/
class CakeLog {
@ -85,6 +84,9 @@ class CakeLog {
/**
* Default log levels as detailed in RFC 5424
* http://tools.ietf.org/html/rfc5424
*
* Windows has fewer levels, thus notice, info and debug are the same.
* https://bugs.php.net/bug.php?id=18090
*
* @var array
*/
@ -119,8 +121,8 @@ class CakeLog {
* @return void
*/
protected static function _init() {
self::$_levels = self::defaultLevels();
self::$_Collection = new LogEngineCollection();
static::$_levels = static::defaultLevels();
static::$_Collection = new LogEngineCollection();
}
/**
@ -130,16 +132,16 @@ class CakeLog {
*
* ### Usage:
*
* {{{
* ```
* CakeLog::config('second_file', array(
* 'engine' => 'FileLog',
* 'engine' => 'File',
* '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
* and handled there. Any class can be configured as a logging
* adapter as long as it implements the methods in CakeLogInterface.
*
* ### Logging levels
@ -147,13 +149,13 @@ class CakeLog {
* When configuring loggers, you can set which levels a logger will handle.
* This allows you to disable debug messages in production for example:
*
* {{{
* ```
* CakeLog::config('default', array(
* 'engine' => 'File',
* 'path' => LOGS,
* 'levels' => array('error', 'critical', 'alert', 'emergency')
* ));
* }}}
* ```
*
* The above logger would only log error messages or higher. Any
* other log messages would be discarded.
@ -161,16 +163,17 @@ class CakeLog {
* ### Logging scopes
*
* When configuring loggers you can define the active scopes the logger
* is for. If defined only the listed scopes will be handled by the
* logger. If you don't define any scopes an adapter will catch
* is for. If defined only the listed scopes will be handled by the
* logger. If you don't define any scopes an adapter will catch
* all scopes that match the handled levels.
*
* {{{
* ```
* CakeLog::config('payments', array(
* 'engine' => 'File',
* 'types' => array('info', 'error', 'warning'),
* 'scopes' => array('payment', 'order')
* ));
* }}}
* ```
*
* The above logger will only capture log entries made in the
* `payment` and `order` scopes. All other scopes including the
@ -182,20 +185,21 @@ class CakeLog {
* @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.
* @return bool success of configuration.
* @throws CakeLogException
* @link http://book.cakephp.org/2.0/en/core-libraries/logging.html#creating-and-configuring-log-streams
*/
public static function config($key, $config) {
if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $key)) {
throw new CakeLogException(__d('cake_dev', 'Invalid key name'));
}
if (empty($config['engine'])) {
throw new CakeLogException(__d('cake_dev', 'Missing logger classname'));
throw new CakeLogException(__d('cake_dev', 'Missing logger class name'));
}
if (empty(self::$_Collection)) {
self::_init();
if (empty(static::$_Collection)) {
static::_init();
}
self::$_Collection->load($key, $config);
static::$_Collection->load($key, $config);
return true;
}
@ -205,10 +209,10 @@ class CakeLog {
* @return array Array of configured log streams.
*/
public static function configured() {
if (empty(self::$_Collection)) {
self::_init();
if (empty(static::$_Collection)) {
static::_init();
}
return self::$_Collection->attached();
return static::$_Collection->loaded();
}
/**
@ -219,15 +223,15 @@ class CakeLog {
*
* To append additional level 'user0' and 'user1' to to default log levels:
*
* {{{
* ```
* CakeLog::levels(array('user0, 'user1'));
* // or
* CakeLog::levels(array('user0, 'user1'), true);
* }}}
* ```
*
* will result in:
*
* {{{
* ```
* array(
* 0 => 'emergency',
* 1 => 'alert',
@ -235,89 +239,89 @@ class CakeLog {
* 8 => 'user0',
* 9 => 'user1',
* );
* }}}
* ```
*
* To set/replace existing configuration, pass an array with the second argument
* set to false.
*
* {{{
* ```
* CakeLog::levels(array('user0, 'user1'), false);
* }}}
* ```
*
* will result in:
*
* {{{
* ```
* array(
* 0 => 'user0',
* 1 => 'user1',
* );
* }}}
* ```
*
* @param array $levels array
* @param bool $append true to append, false to replace
* @return array active log levels
* @return array Active log levels
*/
public static function levels($levels = array(), $append = true) {
if (empty(self::$_Collection)) {
self::_init();
if (empty(static::$_Collection)) {
static::_init();
}
if (empty($levels)) {
return self::$_levels;
return static::$_levels;
}
$levels = array_values($levels);
if ($append) {
self::$_levels = array_merge(self::$_levels, $levels);
static::$_levels = array_merge(static::$_levels, $levels);
} else {
self::$_levels = $levels;
static::$_levels = $levels;
}
self::$_levelMap = array_flip(self::$_levels);
return self::$_levels;
static::$_levelMap = array_flip(static::$_levels);
return static::$_levels;
}
/**
* Reset log levels to the original value
*
* @return array default log levels
* @return array Default log levels
*/
public static function defaultLevels() {
self::$_levelMap = self::$_defaultLevels;
self::$_levels = array_flip(self::$_levelMap);
return self::$_levels;
static::$_levelMap = static::$_defaultLevels;
static::$_levels = array_flip(static::$_levelMap);
return static::$_levels;
}
/**
* Removes a stream from the active streams. Once a stream has been removed
* Removes a stream from the active streams. Once a stream has been removed
* it will no longer have messages sent to it.
*
* @param string $streamName Key name of a configured stream to remove.
* @return void
*/
public static function drop($streamName) {
if (empty(self::$_Collection)) {
self::_init();
if (empty(static::$_Collection)) {
static::_init();
}
self::$_Collection->unload($streamName);
static::$_Collection->unload($streamName);
}
/**
* Checks wether $streamName is enabled
* Checks whether $streamName is enabled
*
* @param string $streamName to check
* @return bool
* @throws CakeLogException
*/
public static function enabled($streamName) {
if (empty(self::$_Collection)) {
self::_init();
if (empty(static::$_Collection)) {
static::_init();
}
if (!isset(self::$_Collection->{$streamName})) {
if (!isset(static::$_Collection->{$streamName})) {
throw new CakeLogException(__d('cake_dev', 'Stream %s not found', $streamName));
}
return self::$_Collection->enabled($streamName);
return static::$_Collection->enabled($streamName);
}
/**
* Enable stream. Streams that were previously disabled
* Enable stream. Streams that were previously disabled
* can be re-enabled with this method.
*
* @param string $streamName to enable
@ -325,17 +329,17 @@ class CakeLog {
* @throws CakeLogException
*/
public static function enable($streamName) {
if (empty(self::$_Collection)) {
self::_init();
if (empty(static::$_Collection)) {
static::_init();
}
if (!isset(self::$_Collection->{$streamName})) {
if (!isset(static::$_Collection->{$streamName})) {
throw new CakeLogException(__d('cake_dev', 'Stream %s not found', $streamName));
}
self::$_Collection->enable($streamName);
static::$_Collection->enable($streamName);
}
/**
* Disable stream. Disabling a stream will
* Disable stream. Disabling a stream will
* prevent that log stream from receiving any messages until
* its re-enabled.
*
@ -344,44 +348,32 @@ class CakeLog {
* @throws CakeLogException
*/
public static function disable($streamName) {
if (empty(self::$_Collection)) {
self::_init();
if (empty(static::$_Collection)) {
static::_init();
}
if (!isset(self::$_Collection->{$streamName})) {
if (!isset(static::$_Collection->{$streamName})) {
throw new CakeLogException(__d('cake_dev', 'Stream %s not found', $streamName));
}
self::$_Collection->disable($streamName);
static::$_Collection->disable($streamName);
}
/**
* Gets the logging engine from the active streams.
*
* @see BaseLog
* @param string $streamName Key name of a configured stream to get.
* @return $mixed instance of BaseLog or false if not found
* @return mixed instance of BaseLog or false if not found
* @see BaseLog
*/
public static function stream($streamName) {
if (empty(self::$_Collection)) {
self::_init();
if (empty(static::$_Collection)) {
static::_init();
}
if (!empty(self::$_Collection->{$streamName})) {
return self::$_Collection->{$streamName};
if (!empty(static::$_Collection->{$streamName})) {
return static::$_Collection->{$streamName};
}
return false;
}
/**
* Configures the automatic/default stream a FileLog.
*
* @return void
*/
protected static function _autoConfig() {
self::$_Collection->load('default', array(
'engine' => 'FileLog',
'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
@ -404,30 +396,31 @@ class CakeLog {
*
* `CakeLog::write('warning', 'Stuff is broken here');`
*
* @param integer|string $type Type of message being written. When value is an integer
* @param int|string $type Type of message being written. When value is an integer
* or a string matching the recognized levels, then it will
* be treated log levels. Otherwise it's treated as scope.
* @param string $message Message content to log
* @param string|array $scope The scope(s) a log message is being created in.
* See CakeLog::config() for more information on logging scopes.
* @return boolean Success
* @return bool Success
* @link http://book.cakephp.org/2.0/en/core-libraries/logging.html#writing-to-logs
*/
public static function write($type, $message, $scope = array()) {
if (empty(self::$_Collection)) {
self::_init();
if (empty(static::$_Collection)) {
static::_init();
}
if (is_int($type) && isset(self::$_levels[$type])) {
$type = self::$_levels[$type];
if (is_int($type) && isset(static::$_levels[$type])) {
$type = static::$_levels[$type];
}
if (is_string($type) && empty($scope) && !in_array($type, self::$_levels)) {
if (is_string($type) && empty($scope) && !in_array($type, static::$_levels)) {
$scope = $type;
}
$logged = false;
foreach (self::$_Collection->enabled() as $streamName) {
$logger = self::$_Collection->{$streamName};
foreach (static::$_Collection->enabled() as $streamName) {
$logger = static::$_Collection->{$streamName};
$types = $scopes = $config = array();
if ($logger instanceof BaseLog) {
if (method_exists($logger, 'config')) {
$config = $logger->config();
}
if (isset($config['types'])) {
@ -453,11 +446,7 @@ class CakeLog {
$logged = true;
}
}
if (!$logged) {
self::_autoConfig();
self::stream('default')->write($type, $message);
}
return true;
return $logged;
}
/**
@ -466,10 +455,10 @@ class CakeLog {
* @param string $message log message
* @param string|array $scope The scope(s) a log message is being created in.
* See CakeLog::config() for more information on logging scopes.
* @return boolean Success
* @return bool Success
*/
public static function emergency($message, $scope = array()) {
return self::write(self::$_levelMap['emergency'], $message, $scope);
return static::write(static::$_levelMap['emergency'], $message, $scope);
}
/**
@ -478,10 +467,10 @@ class CakeLog {
* @param string $message log message
* @param string|array $scope The scope(s) a log message is being created in.
* See CakeLog::config() for more information on logging scopes.
* @return boolean Success
* @return bool Success
*/
public static function alert($message, $scope = array()) {
return self::write(self::$_levelMap['alert'], $message, $scope);
return static::write(static::$_levelMap['alert'], $message, $scope);
}
/**
@ -490,10 +479,10 @@ class CakeLog {
* @param string $message log message
* @param string|array $scope The scope(s) a log message is being created in.
* See CakeLog::config() for more information on logging scopes.
* @return boolean Success
* @return bool Success
*/
public static function critical($message, $scope = array()) {
return self::write(self::$_levelMap['critical'], $message, $scope);
return static::write(static::$_levelMap['critical'], $message, $scope);
}
/**
@ -502,10 +491,10 @@ class CakeLog {
* @param string $message log message
* @param string|array $scope The scope(s) a log message is being created in.
* See CakeLog::config() for more information on logging scopes.
* @return boolean Success
* @return bool Success
*/
public static function error($message, $scope = array()) {
return self::write(self::$_levelMap['error'], $message, $scope);
return static::write(static::$_levelMap['error'], $message, $scope);
}
/**
@ -514,10 +503,10 @@ class CakeLog {
* @param string $message log message
* @param string|array $scope The scope(s) a log message is being created in.
* See CakeLog::config() for more information on logging scopes.
* @return boolean Success
* @return bool Success
*/
public static function warning($message, $scope = array()) {
return self::write(self::$_levelMap['warning'], $message, $scope);
return static::write(static::$_levelMap['warning'], $message, $scope);
}
/**
@ -526,10 +515,10 @@ class CakeLog {
* @param string $message log message
* @param string|array $scope The scope(s) a log message is being created in.
* See CakeLog::config() for more information on logging scopes.
* @return boolean Success
* @return bool Success
*/
public static function notice($message, $scope = array()) {
return self::write(self::$_levelMap['notice'], $message, $scope);
return static::write(static::$_levelMap['notice'], $message, $scope);
}
/**
@ -538,10 +527,10 @@ class CakeLog {
* @param string $message log message
* @param string|array $scope The scope(s) a log message is being created in.
* See CakeLog::config() for more information on logging scopes.
* @return boolean Success
* @return bool Success
*/
public static function debug($message, $scope = array()) {
return self::write(self::$_levelMap['debug'], $message, $scope);
return static::write(static::$_levelMap['debug'], $message, $scope);
}
/**
@ -550,10 +539,10 @@ class CakeLog {
* @param string $message log message
* @param string|array $scope The scope(s) a log message is being created in.
* See CakeLog::config() for more information on logging scopes.
* @return boolean Success
* @return bool Success
*/
public static function info($message, $scope = array()) {
return self::write(self::$_levelMap['info'], $message, $scope);
return static::write(static::$_levelMap['info'], $message, $scope);
}
}

13
lib/Cake/Log/CakeLogInterface.php
View file

@ -2,19 +2,18 @@
/**
* CakeLogInterface
*
* PHP 5
*
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
* Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @copyright Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://cakephp.org CakePHP(tm) Project
* @package Cake.Log
* @since CakePHP(tm) v 2.0
* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
/**
@ -28,8 +27,8 @@ interface CakeLogInterface {
/**
* Write method to handle writes being made to the Logger
*
* @param string $type
* @param string $message
* @param string $type Message type.
* @param string $message Message to write.
* @return void
*/
public function write($type, $message);

21
lib/Cake/Log/Engine/BaseLog.php
View file

@ -2,19 +2,18 @@
/**
* Base Log Engine class
*
* PHP 5
*
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
* Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @copyright Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://www.cakefoundation.org/projects/info/cakephp CakePHP(tm) Project
* @package Cake.Log.Engine
* @since CakePHP(tm) v 2.2
* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('CakeLogInterface', 'Log');
@ -34,16 +33,16 @@ abstract class BaseLog implements CakeLogInterface {
protected $_config = array();
/**
* __construct method
* Constructor
*
* @return void
* @param array $config Configuration array
*/
public function __construct($config = array()) {
$this->config($config);
}
/**
* Sets instance config. When $config is null, returns config array
* Sets instance config. When $config is null, returns config array
*
* Config
*
@ -55,8 +54,10 @@ abstract class BaseLog implements CakeLogInterface {
*/
public function config($config = array()) {
if (!empty($config)) {
if (isset($config['types']) && is_string($config['types'])) {
$config['types'] = array($config['types']);
foreach (array('types', 'scopes') as $option) {
if (isset($config[$option]) && is_string($config[$option])) {
$config[$option] = array($config[$option]);
}
}
$this->_config = $config;
}

17
lib/Cake/Log/Engine/ConsoleLog.php
View file

@ -2,26 +2,25 @@
/**
* Console Logging
*
* PHP 5
*
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
* Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @copyright Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://www.cakefoundation.org/projects/info/cakephp CakePHP(tm) Project
* @package Cake.Log.Engine
* @since CakePHP(tm) v 2.2
* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('BaseLog', 'Log/Engine');
App::uses('ConsoleOutput', 'Console');
/**
* Console logging. Writes logs to console output.
* Console logging. Writes logs to console output.
*
* @package Cake.Log.Engine
*/
@ -49,7 +48,9 @@ class ConsoleLog extends BaseLog {
*/
public function __construct($config = array()) {
parent::__construct($config);
if (DS == '\\' && !(bool)env('ANSICON')) {
if ((DS === '\\' && !(bool)env('ANSICON') && env('ConEmuANSI') !== 'ON') ||
(function_exists('posix_isatty') && !posix_isatty($this->_output))
) {
$outputAs = ConsoleOutput::PLAIN;
} else {
$outputAs = ConsoleOutput::COLOR;
@ -76,7 +77,7 @@ class ConsoleLog extends BaseLog {
*
* @param string $type The type of log you are making.
* @param string $message The message you want to log.
* @return boolean success of write.
* @return bool success of write.
*/
public function write($type, $message) {
$output = date('Y-m-d H:i:s') . ' ' . ucfirst($type) . ': ' . $message . "\n";

190
lib/Cake/Log/Engine/FileLog.php
View file

@ -2,31 +2,48 @@
/**
* File Storage stream for Logging
*
* PHP 5
*
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
* Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @copyright Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://www.cakefoundation.org/projects/info/cakephp CakePHP(tm) Project
* @package Cake.Log.Engine
* @since CakePHP(tm) v 1.3
* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('BaseLog', 'Log/Engine');
App::uses('Hash', 'Utility');
App::uses('CakeNumber', 'Utility');
/**
* File Storage stream for Logging. Writes logs to different files
* File Storage stream for Logging. Writes logs to different files
* based on the type of log it is.
*
* @package Cake.Log.Engine
*/
class FileLog extends BaseLog {
/**
* Default configuration values
*
* @var array
* @see FileLog::__construct()
*/
protected $_defaults = array(
'path' => LOGS,
'file' => null,
'types' => null,
'scopes' => array(),
'rotate' => 10,
'size' => 10485760, // 10MB
'mask' => null,
);
/**
* Path to save log files on.
*
@ -34,6 +51,20 @@ class FileLog extends BaseLog {
*/
protected $_path = null;
/**
* Log file name
*
* @var string
*/
protected $_file = null;
/**
* Max file size, used for log file rotation.
*
* @var int
*/
protected $_size = null;
/**
* Constructs a new File Logger.
*
@ -41,25 +72,55 @@ class FileLog extends BaseLog {
*
* - `types` string or array, levels the engine is interested in
* - `scopes` string or array, scopes the engine is interested in
* - `file` log file name
* - `path` the path to save logs on.
* - `file` Log file name
* - `path` The path to save logs on.
* - `size` Used to implement basic log file rotation. If log file size
* reaches specified size the existing file is renamed by appending timestamp
* to filename and new log file is created. Can be integer bytes value or
* human reabable string values like '10MB', '100KB' etc.
* - `rotate` Log files are rotated specified times before being removed.
* If value is 0, old versions are removed rather then rotated.
* - `mask` A mask is applied when log files are created. Left empty no chmod
* is made.
*
* @param array $options Options for the FileLog, see above.
* @param array $config Options for the FileLog, see above.
*/
public function __construct($config = array()) {
$config = Hash::merge($this->_defaults, $config);
parent::__construct($config);
$config = Hash::merge(array(
'path' => LOGS,
'file' => null,
'types' => null,
'scopes' => array(),
), $this->_config);
$config = $this->config($config);
$this->_path = $config['path'];
$this->_file = $config['file'];
if (!empty($this->_file) && !preg_match('/\.log$/', $this->_file)) {
$this->_file .= '.log';
}
/**
* Sets protected properties based on config provided
*
* @param array $config Engine configuration
* @return array
*/
public function config($config = array()) {
parent::config($config);
if (!empty($config['path'])) {
$this->_path = $config['path'];
}
if (Configure::read('debug') && !is_dir($this->_path)) {
mkdir($this->_path, 0775, true);
}
if (!empty($config['file'])) {
$this->_file = $config['file'];
if (substr($this->_file, -4) !== '.log') {
$this->_file .= '.log';
}
}
if (!empty($config['size'])) {
if (is_numeric($config['size'])) {
$this->_size = (int)$config['size'];
} else {
$this->_size = CakeNumber::fromReadableSize($config['size']);
}
}
return $this->_config;
}
/**
@ -67,24 +128,93 @@ class FileLog extends BaseLog {
*
* @param string $type The type of log you are making.
* @param string $message The message you want to log.
* @return boolean success of write.
* @return bool success of write.
*/
public function write($type, $message) {
$output = date('Y-m-d H:i:s') . ' ' . ucfirst($type) . ': ' . $message . "\n";
$filename = $this->_getFilename($type);
if (!empty($this->_size)) {
$this->_rotateFile($filename);
}
$pathname = $this->_path . $filename;
if (empty($this->_config['mask'])) {
return file_put_contents($pathname, $output, FILE_APPEND);
}
$exists = file_exists($pathname);
$result = file_put_contents($pathname, $output, FILE_APPEND);
static $selfError = false;
if (!$selfError && !$exists && !chmod($pathname, (int)$this->_config['mask'])) {
$selfError = true;
trigger_error(__d(
'cake_dev', 'Could not apply permission mask "%s" on log file "%s"',
array($this->_config['mask'], $pathname)), E_USER_WARNING);
$selfError = false;
}
return $result;
}
/**
* Get filename
*
* @param string $type The type of log.
* @return string File name
*/
protected function _getFilename($type) {
$debugTypes = array('notice', 'info', 'debug');
if (!empty($this->_file)) {
$filename = $this->_path . $this->_file;
} elseif ($type == 'error' || $type == 'warning') {
$filename = $this->_path . 'error.log';
$filename = $this->_file;
} elseif ($type === 'error' || $type === 'warning') {
$filename = 'error.log';
} elseif (in_array($type, $debugTypes)) {
$filename = $this->_path . 'debug.log';
} elseif (in_array($type, $this->_config['scopes'])) {
$filename = $this->_path . $this->_file;
$filename = 'debug.log';
} else {
$filename = $this->_path . $type . '.log';
$filename = $type . '.log';
}
$output = date('Y-m-d H:i:s') . ' ' . ucfirst($type) . ': ' . $message . "\n";
return file_put_contents($filename, $output, FILE_APPEND);
return $filename;
}
/**
* Rotate log file if size specified in config is reached.
* Also if `rotate` count is reached oldest file is removed.
*
* @param string $filename Log file name
* @return mixed True if rotated successfully or false in case of error, otherwise null.
* Void if file doesn't need to be rotated.
*/
protected function _rotateFile($filename) {
$filepath = $this->_path . $filename;
if (version_compare(PHP_VERSION, '5.3.0') >= 0) {
clearstatcache(true, $filepath);
} else {
clearstatcache();
}
if (!file_exists($filepath) ||
filesize($filepath) < $this->_size
) {
return null;
}
if ($this->_config['rotate'] === 0) {
$result = unlink($filepath);
} else {
$result = rename($filepath, $filepath . '.' . time());
}
$files = glob($filepath . '.*');
if ($files) {
$filesToDelete = count($files) - $this->_config['rotate'];
while ($filesToDelete > 0) {
unlink(array_shift($files));
$filesToDelete--;
}
}
return $result;
}
}

158
lib/Cake/Log/Engine/SyslogLog.php Normal file
View file

@ -0,0 +1,158 @@
<?php
/**
* Syslog logger engine for CakePHP
*
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://www.cakefoundation.org/projects/info/cakephp CakePHP(tm) Project
* @package Cake.Log.Engine
* @since CakePHP(tm) v 2.4
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('BaseLog', 'Log/Engine');
/**
* Syslog stream for Logging. Writes logs to the system logger
*
* @package Cake.Log.Engine
*/
class SyslogLog extends BaseLog {
/**
* By default messages are formatted as:
* type: message
*
* To override the log format (e.g. to add your own info) define the format key when configuring
* this logger
*
* If you wish to include a prefix to all messages, for instance to identify the
* application or the web server, then use the prefix option. Please keep in mind
* the prefix is shared by all streams using syslog, as it is dependent of
* the running process. For a local prefix, to be used only by one stream, you
* can use the format key.
*
* ## Example:
*
* ```
* CakeLog::config('error', array(
* 'engine' => 'Syslog',
* 'types' => array('emergency', 'alert', 'critical', 'error'),
* 'format' => "%s: My-App - %s",
* 'prefix' => 'Web Server 01'
* ));
* ```
*
* @var array
*/
protected $_defaults = array(
'format' => '%s: %s',
'flag' => LOG_ODELAY,
'prefix' => '',
'facility' => LOG_USER
);
/**
* Used to map the string names back to their LOG_* constants
*
* @var array
*/
protected $_priorityMap = array(
'emergency' => LOG_EMERG,
'alert' => LOG_ALERT,
'critical' => LOG_CRIT,
'error' => LOG_ERR,
'warning' => LOG_WARNING,
'notice' => LOG_NOTICE,
'info' => LOG_INFO,
'debug' => LOG_DEBUG
);
/**
* Whether the logger connection is open or not
*
* @var bool
*/
protected $_open = false;
/**
* Make sure the configuration contains the format parameter, by default it uses
* the error number and the type as a prefix to the message
*
* @param array $config Options list.
*/
public function __construct($config = array()) {
$config += $this->_defaults;
parent::__construct($config);
}
/**
* Writes a message to syslog
*
* Map the $type back to a LOG_ constant value, split multi-line messages into multiple
* log messages, pass all messages through the format defined in the configuration
*
* @param string $type The type of log you are making.
* @param string $message The message you want to log.
* @return bool success of write.
*/
public function write($type, $message) {
if (!$this->_open) {
$config = $this->_config;
$this->_open($config['prefix'], $config['flag'], $config['facility']);
$this->_open = true;
}
$priority = LOG_DEBUG;
if (isset($this->_priorityMap[$type])) {
$priority = $this->_priorityMap[$type];
}
$messages = explode("\n", $message);
foreach ($messages as $message) {
$message = sprintf($this->_config['format'], $type, $message);
$this->_write($priority, $message);
}
return true;
}
/**
* Extracts the call to openlog() in order to run unit tests on it. This function
* will initialize the connection to the system logger
*
* @param string $ident the prefix to add to all messages logged
* @param int $options the options flags to be used for logged messages
* @param int $facility the stream or facility to log to
* @return void
*/
protected function _open($ident, $options, $facility) {
openlog($ident, $options, $facility);
}
/**
* Extracts the call to syslog() in order to run unit tests on it. This function
* will perform the actual write in the system logger
*
* @param int $priority Message priority.
* @param string $message Message to log.
* @return bool
*/
protected function _write($priority, $message) {
return syslog($priority, $message);
}
/**
* Closes the logger connection
*/
public function __destruct() {
closelog();
}
}

19
lib/Cake/Log/LogEngineCollection.php
View file

@ -2,19 +2,18 @@
/**
* Registry of loaded log engines
*
* PHP 5
*
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
* Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
*
* Licensed under The MIT License
* For full copyright and license information, please see the LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @copyright Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
* @link http://cakephp.org CakePHP(tm) Project
* @package Cake.Log
* @since CakePHP(tm) v 2.2
* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
App::uses('ObjectCollection', 'Utility');
@ -41,9 +40,9 @@ class LogEngineCollection extends ObjectCollection {
$className = $this->_getLogger($loggerName);
$logger = new $className($options);
if (!$logger instanceof CakeLogInterface) {
throw new CakeLogException(sprintf(
__d('cake_dev', 'logger class %s does not implement a write method.'), $loggerName
));
throw new CakeLogException(
__d('cake_dev', 'logger class %s does not implement a %s method.', $loggerName, 'write()')
);
}
$this->_loaded[$name] = $logger;
if ($enable) {
@ -62,7 +61,9 @@ class LogEngineCollection extends ObjectCollection {
*/
protected static function _getLogger($loggerName) {
list($plugin, $loggerName) = pluginSplit($loggerName, true);
if (substr($loggerName, -3) !== 'Log') {
$loggerName .= 'Log';
}
App::uses($loggerName, $plugin . 'Log/Engine');
if (!class_exists($loggerName)) {
throw new CakeLogException(__d('cake_dev', 'Could not load class %s', $loggerName));