bfw: comparison library/log4php/Logger.php

equal deleted inserted replaced

--1:000000000000
+:4869aea77e21
+<?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;
+}
+}