Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
84.09% |
37 / 44 |
CRAP | |
76.15% |
99 / 130 |
| Logger | |
0.00% |
0 / 1 |
|
84.09% |
37 / 44 |
136.44 | |
76.15% |
99 / 130 |
| __construct($name) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| getName() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getParent() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| trace($message, $throwable = null) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| debug($message, $throwable = null) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| info($message, $throwable = null) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| warn($message, $throwable = null) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| error($message, $throwable = null) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| fatal($message, $throwable = null) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| log(LoggerLevel $level, $message, $throwable = null) | |
100.00% |
1 / 1 |
5 | |
100.00% |
11 / 11 |
|||
| logEvent(LoggerLoggingEvent $event) | |
100.00% |
1 / 1 |
4 | |
100.00% |
7 / 7 |
|||
| assertLog($assertion = true, $msg = '') | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 4 |
|||
| forcedLog($fqcn, $throwable, LoggerLevel $level, $message) | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 6 |
|||
| callAppenders($event) | |
100.00% |
1 / 1 |
2 | |
100.00% |
4 / 4 |
|||
| isEnabledFor(LoggerLevel $level) | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| isTraceEnabled() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| isDebugEnabled() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| isInfoEnabled() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| isWarnEnabled() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| isErrorEnabled() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| isFatalEnabled() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| addAppender($appender) | |
100.00% |
1 / 1 |
1 | |
100.00% |
3 / 3 |
|||
| removeAllAppenders() | |
100.00% |
1 / 1 |
2 | |
100.00% |
4 / 4 |
|||
| removeAppender($appender) | |
0.00% |
0 / 1 |
4.25 | |
75.00% |
6 / 8 |
|||
| getAllAppenders() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getAppender($name) | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| setAdditivity($additive) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| getAdditivity() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getEffectiveLevel() | |
0.00% |
0 / 1 |
3.07 | |
80.00% |
4 / 5 |
|||
| getLevel() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| setLevel(LoggerLevel $level = null) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| isAttached(LoggerAppender $appender) | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| setParent(Logger $logger) | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| getHierarchy() | |
100.00% |
1 / 1 |
2 | |
100.00% |
4 / 4 |
|||
| getLogger($name) | |
100.00% |
1 / 1 |
2 | |
100.00% |
4 / 4 |
|||
| getRootLogger() | |
100.00% |
1 / 1 |
2 | |
100.00% |
4 / 4 |
|||
| clear() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| resetConfiguration() | |
100.00% |
1 / 1 |
1 | |
100.00% |
4 / 4 |
|||
| shutdown() | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| exists($name) | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getCurrentLoggers() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| configure($configuration = null, $configurator = null) | |
100.00% |
1 / 1 |
1 | |
100.00% |
5 / 5 |
|||
| getConfigurator($configurator = null) | |
0.00% |
0 / 1 |
41.41 | |
11.11% |
2 / 18 |
|||
| isInitialized() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| <?php | |
| /** | |
| * Licensed to the Apache Software Foundation (ASF) under one or more | |
| * contributor license agreements. See the NOTICE file distributed with | |
| * this work for additional information regarding copyright ownership. | |
| * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| * (the "License"); you may not use this file except in compliance with | |
| * the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| * | |
| * @package log4php | |
| */ | |
| require dirname(__FILE__) . '/LoggerAutoloader.php'; | |
| /** | |
| * This is the central class in the log4php package. All logging operations | |
| * are done through this class. | |
| * | |
| * The main logging methods are: | |
| * <ul> | |
| * <li>{@link trace()}</li> | |
| * <li>{@link debug()}</li> | |
| * <li>{@link info()}</li> | |
| * <li>{@link warn()}</li> | |
| * <li>{@link error()}</li> | |
| * <li>{@link fatal()}</li> | |
| * </ul> | |
| * | |
| * @package log4php | |
| * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0 | |
| * @version SVN: $Id: Logger.php 1395241 2012-10-07 08:28:53Z ihabunek $ | |
| * @link http://logging.apache.org/log4php | |
| */ | |
| class Logger { | |
| /** | |
| * Logger additivity. If set to true then child loggers will inherit | |
| * the appenders of their ancestors by default. | |
| * @var boolean | |
| */ | |
| private $additive = true; | |
| /** | |
| * The Logger's fully qualified class name. | |
| * TODO: Determine if this is useful. | |
| */ | |
| private $fqcn = 'Logger'; | |
| /** The assigned Logger level. */ | |
| private $level; | |
| /** The name of this Logger instance. */ | |
| private $name; | |
| /** The parent logger. Set to null if this is the root logger. */ | |
| private $parent; | |
| /** A collection of appenders linked to this logger. */ | |
| private $appenders = array(); | |
| /** | |
| * Constructor. | |
| * @param string $name Name of the logger. | |
| */ | |
| public function __construct($name) { | |
| $this->name = $name; | |
| } | |
| /** | |
| * Returns the logger name. | |
| * @return string | |
| */ | |
| public function getName() { | |
| return $this->name; | |
| } | |
| /** | |
| * Returns the parent Logger. Can be null if this is the root logger. | |
| * @return Logger | |
| */ | |
| public function getParent() { | |
| return $this->parent; | |
| } | |
| // ****************************************** | |
| // *** Logging methods *** | |
| // ****************************************** | |
| /** | |
| * Log a message object with the TRACE level. | |
| * | |
| * @param mixed $message message | |
| * @param Exception $throwable Optional throwable information to include | |
| * in the logging event. | |
| */ | |
| public function trace($message, $throwable = null) { | |
| $this->log(LoggerLevel::getLevelTrace(), $message, $throwable); | |
| } | |
| /** | |
| * Log a message object with the DEBUG level. | |
| * | |
| * @param mixed $message message | |
| * @param Exception $throwable Optional throwable information to include | |
| * in the logging event. | |
| */ | |
| public function debug($message, $throwable = null) { | |
| $this->log(LoggerLevel::getLevelDebug(), $message, $throwable); | |
| } | |
| /** | |
| * Log a message object with the INFO Level. | |
| * | |
| * @param mixed $message message | |
| * @param Exception $throwable Optional throwable information to include | |
| * in the logging event. | |
| */ | |
| public function info($message, $throwable = null) { | |
| $this->log(LoggerLevel::getLevelInfo(), $message, $throwable); | |
| } | |
| /** | |
| * Log a message with the WARN level. | |
| * | |
| * @param mixed $message message | |
| * @param Exception $throwable Optional throwable information to include | |
| * in the logging event. | |
| */ | |
| public function warn($message, $throwable = null) { | |
| $this->log(LoggerLevel::getLevelWarn(), $message, $throwable); | |
| } | |
| /** | |
| * Log a message object with the ERROR level. | |
| * | |
| * @param mixed $message message | |
| * @param Exception $throwable Optional throwable information to include | |
| * in the logging event. | |
| */ | |
| public function error($message, $throwable = null) { | |
| $this->log(LoggerLevel::getLevelError(), $message, $throwable); | |
| } | |
| /** | |
| * Log a message object with the FATAL level. | |
| * | |
| * @param mixed $message message | |
| * @param Exception $throwable Optional throwable information to include | |
| * in the logging event. | |
| */ | |
| public function fatal($message, $throwable = null) { | |
| $this->log(LoggerLevel::getLevelFatal(), $message, $throwable); | |
| } | |
| /** | |
| * Log a message using the provided logging level. | |
| * | |
| * @param LoggerLevel $level The logging level. | |
| * @param mixed $message Message to log. | |
| * @param Exception $throwable Optional throwable information to include | |
| * in the logging event. | |
| */ | |
| public function log(LoggerLevel $level, $message, $throwable = null) { | |
| if($this->isEnabledFor($level)) { | |
| $event = new LoggerLoggingEvent($this->fqcn, $this, $level, $message, null, $throwable); | |
| $this->callAppenders($event); | |
| } | |
| // Forward the event upstream if additivity is turned on | |
| if(isset($this->parent) && $this->getAdditivity()) { | |
| // Use the event if already created | |
| if (isset($event)) { | |
| $this->parent->logEvent($event); | |
| } else { | |
| $this->parent->log($level, $message, $throwable); | |
| } | |
| } | |
| } | |
| /** | |
| * Logs an already prepared logging event object. | |
| * @param LoggerLoggingEvent $event | |
| */ | |
| public function logEvent(LoggerLoggingEvent $event) { | |
| if($this->isEnabledFor($event->getLevel())) { | |
| $this->callAppenders($event); | |
| } | |
| // Forward the event upstream if additivity is turned on | |
| if(isset($this->parent) && $this->getAdditivity()) { | |
| $this->parent->logEvent($event); | |
| } | |
| } | |
| /** | |
| * If assertion parameter evaluates as false, then logs the message | |
| * using the ERROR level. | |
| * | |
| * @param bool $assertion | |
| * @param string $msg message to log | |
| */ | |
| public function assertLog($assertion = true, $msg = '') { | |
| if($assertion == false) { | |
| $this->error($msg); | |
| } | |
| } | |
| /** | |
| * This method creates a new logging event and logs the event without | |
| * further checks. | |
| * | |
| * It should not be called directly. Use {@link trace()}, {@link debug()}, | |
| * {@link info()}, {@link warn()}, {@link error()} and {@link fatal()} | |
| * wrappers. | |
| * | |
| * @param string $fqcn Fully qualified class name of the Logger | |
| * @param Exception $throwable Optional throwable information to include | |
| * in the logging event. | |
| * @param LoggerLevel $level log level | |
| * @param mixed $message message to log | |
| */ | |
| public function forcedLog($fqcn, $throwable, LoggerLevel $level, $message) { | |
| $event = new LoggerLoggingEvent($fqcn, $this, $level, $message, null, $throwable); | |
| $this->callAppenders($event); | |
| // Forward the event upstream if additivity is turned on | |
| if(isset($this->parent) && $this->getAdditivity()) { | |
| $this->parent->logEvent($event); | |
| } | |
| } | |
| /** | |
| * Forwards the given logging event to all linked appenders. | |
| * @param LoggerLoggingEvent $event | |
| */ | |
| public function callAppenders($event) { | |
| foreach($this->appenders as $appender) { | |
| $appender->doAppend($event); | |
| } | |
| } | |
| // ****************************************** | |
| // *** Checker methods *** | |
| // ****************************************** | |
| /** | |
| * Check whether this Logger is enabled for a given Level passed as parameter. | |
| * | |
| * @param LoggerLevel level | |
| * @return boolean | |
| */ | |
| public function isEnabledFor(LoggerLevel $level) { | |
| return $level->isGreaterOrEqual($this->getEffectiveLevel()); | |
| } | |
| /** | |
| * Check whether this Logger is enabled for the TRACE Level. | |
| * @return boolean | |
| */ | |
| public function isTraceEnabled() { | |
| return $this->isEnabledFor(LoggerLevel::getLevelTrace()); | |
| } | |
| /** | |
| * Check whether this Logger is enabled for the DEBUG Level. | |
| * @return boolean | |
| */ | |
| public function isDebugEnabled() { | |
| return $this->isEnabledFor(LoggerLevel::getLevelDebug()); | |
| } | |
| /** | |
| * Check whether this Logger is enabled for the INFO Level. | |
| * @return boolean | |
| */ | |
| public function isInfoEnabled() { | |
| return $this->isEnabledFor(LoggerLevel::getLevelInfo()); | |
| } | |
| /** | |
| * Check whether this Logger is enabled for the WARN Level. | |
| * @return boolean | |
| */ | |
| public function isWarnEnabled() { | |
| return $this->isEnabledFor(LoggerLevel::getLevelWarn()); | |
| } | |
| /** | |
| * Check whether this Logger is enabled for the ERROR Level. | |
| * @return boolean | |
| */ | |
| public function isErrorEnabled() { | |
| return $this->isEnabledFor(LoggerLevel::getLevelError()); | |
| } | |
| /** | |
| * Check whether this Logger is enabled for the FATAL Level. | |
| * @return boolean | |
| */ | |
| public function isFatalEnabled() { | |
| return $this->isEnabledFor(LoggerLevel::getLevelFatal()); | |
| } | |
| // ****************************************** | |
| // *** Configuration methods *** | |
| // ****************************************** | |
| /** | |
| * Adds a new appender to the Logger. | |
| * @param LoggerAppender $appender The appender to add. | |
| */ | |
| public function addAppender($appender) { | |
| $appenderName = $appender->getName(); | |
| $this->appenders[$appenderName] = $appender; | |
| } | |
| /** Removes all appenders from the Logger. */ | |
| public function removeAllAppenders() { | |
| foreach($this->appenders as $name => $appender) { | |
| $this->removeAppender($name); | |
| } | |
| } | |
| /** | |
| * Remove the appender passed as parameter form the Logger. | |
| * @param mixed $appender an appender name or a {@link LoggerAppender} instance. | |
| */ | |
| public function removeAppender($appender) { | |
| if($appender instanceof LoggerAppender) { | |
| $appender->close(); | |
| unset($this->appenders[$appender->getName()]); | |
| } else if (is_string($appender) and isset($this->appenders[$appender])) { | |
| $this->appenders[$appender]->close(); | |
| unset($this->appenders[$appender]); | |
| } | |
| } | |
| /** | |
| * Returns the appenders linked to this logger as an array. | |
| * @return array collection of appender names | |
| */ | |
| public function getAllAppenders() { | |
| return $this->appenders; | |
| } | |
| /** | |
| * Returns a linked appender by name. | |
| * @return LoggerAppender | |
| */ | |
| public function getAppender($name) { | |
| return $this->appenders[$name]; | |
| } | |
| /** | |
| * Sets the additivity flag. | |
| * @param boolean $additive | |
| */ | |
| public function setAdditivity($additive) { | |
| $this->additive = (bool)$additive; | |
| } | |
| /** | |
| * Returns the additivity flag. | |
| * @return boolean | |
| */ | |
| public function getAdditivity() { | |
| return $this->additive; | |
| } | |
| /** | |
| * Starting from this Logger, search the Logger hierarchy for a non-null level and return it. | |
| * @see LoggerLevel | |
| * @return LoggerLevel or null | |
| */ | |
| public function getEffectiveLevel() { | |
| for($logger = $this; $logger !== null; $logger = $logger->getParent()) { | |
| if($logger->getLevel() !== null) { | |
| return $logger->getLevel(); | |
| } | |
| } | |
| } | |
| /** | |
| * Get the assigned Logger level. | |
| * @return LoggerLevel The assigned level or null if none is assigned. | |
| */ | |
| public function getLevel() { | |
| return $this->level; | |
| } | |
| /** | |
| * Set the Logger level. | |
| * | |
| * Use LoggerLevel::getLevelXXX() methods to get a LoggerLevel object, e.g. | |
| * <code>$logger->setLevel(LoggerLevel::getLevelInfo());</code> | |
| * | |
| * @param LoggerLevel $level The level to set, or NULL to clear the logger level. | |
| */ | |
| public function setLevel(LoggerLevel $level = null) { | |
| $this->level = $level; | |
| } | |
| /** | |
| * Checks whether an appender is attached to this logger instance. | |
| * | |
| * @param LoggerAppender $appender | |
| * @return boolean | |
| */ | |
| public function isAttached(LoggerAppender $appender) { | |
| return isset($this->appenders[$appender->getName()]); | |
| } | |
| /** | |
| * Sets the parent logger. | |
| * @param Logger $logger | |
| */ | |
| public function setParent(Logger $logger) { | |
| $this->parent = $logger; | |
| } | |
| // ****************************************** | |
| // *** Static methods and properties *** | |
| // ****************************************** | |
| /** The logger hierarchy used by log4php. */ | |
| private static $hierarchy; | |
| /** Inidicates if log4php has been initialized */ | |
| private static $initialized = false; | |
| /** | |
| * Returns the hierarchy used by this Logger. | |
| * | |
| * Caution: do not use this hierarchy unless you have called initialize(). | |
| * To get Loggers, use the Logger::getLogger and Logger::getRootLogger | |
| * methods instead of operating on on the hierarchy directly. | |
| * | |
| * @return LoggerHierarchy | |
| */ | |
| public static function getHierarchy() { | |
| if(!isset(self::$hierarchy)) { | |
| self::$hierarchy = new LoggerHierarchy(new LoggerRoot()); | |
| } | |
| return self::$hierarchy; | |
| } | |
| /** | |
| * Returns a Logger by name. If it does not exist, it will be created. | |
| * | |
| * @param string $name The logger name | |
| * @return Logger | |
| */ | |
| public static function getLogger($name) { | |
| if(!self::isInitialized()) { | |
| self::configure(); | |
| } | |
| return self::getHierarchy()->getLogger($name); | |
| } | |
| /** | |
| * Returns the Root Logger. | |
| * @return LoggerRoot | |
| */ | |
| public static function getRootLogger() { | |
| if(!self::isInitialized()) { | |
| self::configure(); | |
| } | |
| return self::getHierarchy()->getRootLogger(); | |
| } | |
| /** | |
| * Clears all Logger definitions from the logger hierarchy. | |
| * @return boolean | |
| */ | |
| public static function clear() { | |
| return self::getHierarchy()->clear(); | |
| } | |
| /** | |
| * Destroy configurations for logger definitions | |
| */ | |
| public static function resetConfiguration() { | |
| self::getHierarchy()->resetConfiguration(); | |
| self::getHierarchy()->clear(); // TODO: clear or not? | |
| self::$initialized = false; | |
| } | |
| /** | |
| * Safely close all appenders. | |
| * @deprecated This is no longer necessary due the appenders shutdown via | |
| * destructors. | |
| */ | |
| public static function shutdown() { | |
| return self::getHierarchy()->shutdown(); | |
| } | |
| /** | |
| * check if a given logger exists. | |
| * | |
| * @param string $name logger name | |
| * @return boolean | |
| */ | |
| public static function exists($name) { | |
| return self::getHierarchy()->exists($name); | |
| } | |
| /** | |
| * Returns an array this whole Logger instances. | |
| * @see Logger | |
| * @return array | |
| */ | |
| public static function getCurrentLoggers() { | |
| return self::getHierarchy()->getCurrentLoggers(); | |
| } | |
| /** | |
| * Configures log4php. | |
| * | |
| * This method needs to be called before the first logging event has | |
| * occured. If this method is not called before then the default | |
| * configuration will be used. | |
| * | |
| * @param string|array $configuration Either a path to the configuration | |
| * file, or a configuration array. | |
| * | |
| * @param string|LoggerConfigurator $configurator A custom | |
| * configurator class: either a class name (string), or an object which | |
| * implements the LoggerConfigurator interface. If left empty, the default | |
| * configurator implementation will be used. | |
| */ | |
| public static function configure($configuration = null, $configurator = null) { | |
| self::resetConfiguration(); | |
| $configurator = self::getConfigurator($configurator); | |
| $configurator->configure(self::getHierarchy(), $configuration); | |
| self::$initialized = true; | |
| } | |
| /** | |
| * Creates a logger configurator instance based on the provided | |
| * configurator class. If no class is given, returns an instance of | |
| * the default configurator. | |
| * | |
| * @param string|LoggerConfigurator $configurator The configurator class | |
| * or LoggerConfigurator instance. | |
| */ | |
| private static function getConfigurator($configurator = null) { | |
| if ($configurator === null) { | |
| return new LoggerConfiguratorDefault(); | |
| } | |
| if (is_object($configurator)) { | |
| if ($configurator instanceof LoggerConfigurator) { | |
| return $configurator; | |
| } else { | |
| trigger_error("log4php: Given configurator object [$configurator] does not implement the LoggerConfigurator interface. Reverting to default configurator.", E_USER_WARNING); | |
| return new LoggerConfiguratorDefault(); | |
| } | |
| } | |
| if (is_string($configurator)) { | |
| if (!class_exists($configurator)) { | |
| trigger_error("log4php: Specified configurator class [$configurator] does not exist. Reverting to default configurator.", E_USER_WARNING); | |
| return new LoggerConfiguratorDefault(); | |
| } | |
| $instance = new $configurator(); | |
| if (!($instance instanceof LoggerConfigurator)) { | |
| trigger_error("log4php: Specified configurator class [$configurator] does not implement the LoggerConfigurator interface. Reverting to default configurator.", E_USER_WARNING); | |
| return new LoggerConfiguratorDefault(); | |
| } | |
| return $instance; | |
| } | |
| trigger_error("log4php: Invalid configurator specified. Expected either a string or a LoggerConfigurator instance. Reverting to default configurator.", E_USER_WARNING); | |
| return new LoggerConfiguratorDefault(); | |
| } | |
| /** | |
| * Returns true if the log4php framework has been initialized. | |
| * @return boolean | |
| */ | |
| private static function isInitialized() { | |
| return self::$initialized; | |
| } | |
| } |