<?php
/**
* log4php is a PHP port of the log4j java logging package.
*
* <p>This framework is based on log4j (see {@link http://jakarta.apache.org/log4j log4j} for details).</p>
* <p>Design, strategies and part of the methods documentation are developed by log4j team
* (Ceki Gülcü as log4j project founder and
* {@link http://jakarta.apache.org/log4j/docs/contributors.html contributors}).</p>
*
* <p>PHP port, extensions and modifications by VxR. All rights reserved.<br>
* For more information, please see {@link http://www.vxr.it/log4php/}.</p>
*
* <p>This software is published under the terms of the LGPL License
* a copy of which has been included with this distribution in the LICENSE file.</p>
*
* @package log4php
*/
/**
* @ignore
*/
if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__));
require_once(LOG4PHP_DIR . '/config/LoggerPropertySetter.php');
require_once(LOG4PHP_DIR . '/helpers/LoggerOptionConverter.php');
require_once(LOG4PHP_DIR . '/or/LoggerObjectRenderer.php');
require_once(LOG4PHP_DIR . '/or/LoggerRendererMap.php');
require_once(LOG4PHP_DIR . '/spi/LoggerConfigurator.php');
require_once(LOG4PHP_DIR . '/spi/LoggerFilter.php');
require_once(LOG4PHP_DIR . '/LoggerAppender.php');
require_once(LOG4PHP_DIR . '/LoggerDefaultCategoryFactory.php');
require_once(LOG4PHP_DIR . '/LoggerLayout.php');
require_once(LOG4PHP_DIR . '/LoggerLevel.php');
require_once(LOG4PHP_DIR . '/LoggerManager.php');
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX', "log4php.category.");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX', "log4php.logger.");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_FACTORY_PREFIX', "log4php.factory");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ADDITIVITY_PREFIX', "log4php.additivity.");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_CATEGORY_PREFIX', "log4php.rootCategory");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_LOGGER_PREFIX', "log4php.rootLogger");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_APPENDER_PREFIX', "log4php.appender.");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_RENDERER_PREFIX', "log4php.renderer.");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_THRESHOLD_PREFIX', "log4php.threshold");
/**
* Key for specifying the {@link LoggerFactory}.
*/
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_FACTORY_KEY', "log4php.loggerFactory");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_DEBUG_KEY', "log4php.debug");
define('LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_INTERNAL_ROOT_NAME', "root");
/**
* Allows the configuration of log4php from an external file.
*
* See {@link doConfigure()} for the expected format.
*
* <p>It is sometimes useful to see how log4php is reading configuration
* files. You can enable log4php internal logging by defining the
* <b>log4php.debug</b> variable.</p>
*
* <p>The <i>LoggerPropertyConfigurator</i> does not handle the
* advanced configuration features supported by the {@link LoggerDOMConfigurator}
* such as support for {@link LoggerFilter},
custom {@link LoggerErrorHandlers}, nested appenders such as the
{@link Logger AsyncAppender},
* etc.
*
* <p>All option <i>values</i> admit variable substitution. The
* syntax of variable substitution is similar to that of Unix
* shells. The string between an opening <b>"${"</b> and
* closing <b>"}"</b> is interpreted as a key. The value of
* the substituted variable can be defined as a system property or in
* the configuration file itself. The value of the key is first
* searched in the defined constants, in the enviroments variables
* and if not found there, it is
* then searched in the configuration file being parsed. The
* corresponding value replaces the ${variableName} sequence.</p>
* <p>For example, if <b>$_ENV['home']</b> env var is set to
* <b>/home/xyz</b>, then every occurrence of the sequence
* <b>${home}</b> will be interpreted as
* <b>/home/xyz</b>. See {@link LoggerOptionConverter::getSystemProperty()}
* for details.</p>
*
* @author VxR <vxr@vxr.it>
* @version $Revision: 1.1 $
* @package log4php
* @since 0.5
*/
class LoggerPropertyConfigurator extends LoggerConfigurator {
/**
* @var LoggerFactory
*/
var $loggerFactory = null;
/**
* Constructor
*/
function LoggerPropertyConfigurator()
{
$this->loggerFactory = new LoggerDefaultCategoryFactory();
}
/**
* Configure the default repository using the resource pointed by <b>url</b>.
* <b>Url</b> is any valid resurce as defined in {@link PHP_MANUAL#file} function.
* Note that the resource will be search with <i>use_include_path</i> parameter
* set to "1".
*
* @param string $url
* @return boolean configuration result
* @static
*/
function configure($url = '')
{
$configurator = new LoggerPropertyConfigurator();
$repository =& LoggerManager::getLoggerRepository();
return $configurator->doConfigure($url, $repository);
}
/**
* Read configuration from a file.
*
* <p>The function {@link PHP_MANUAL#parse_ini_file} is used to read the
* file.</p>
*
* <b>The existing configuration is not cleared nor reset.</b>
* If you require a different behavior, then call
* {@link LoggerManager::resetConfiguration()}
* method before calling {@link doConfigure()}.
*
* <p>The configuration file consists of statements in the format
* <b>key=value</b>. The syntax of different configuration
* elements are discussed below.
*
* <p><b>Repository-wide threshold</b></p>
*
* <p>The repository-wide threshold filters logging requests by level
* regardless of logger. The syntax is:
*
* <pre>
* log4php.threshold=[level]
* </pre>
*
* <p>The level value can consist of the string values OFF, FATAL,
* ERROR, WARN, INFO, DEBUG, ALL or a <i>custom level</i> value. A
* custom level value can be specified in the form
* <samp>level#classname</samp>. By default the repository-wide threshold is set
* to the lowest possible value, namely the level <b>ALL</b>.
* </p>
*
*
* <p><b>Appender configuration</b></p>
*
* <p>Appender configuration syntax is:</p>
* <pre>
* ; For appender named <i>appenderName</i>, set its class.
* ; Note: The appender name can contain dots.
* log4php.appender.appenderName=name_of_appender_class
*
* ; Set appender specific options.
*
* log4php.appender.appenderName.option1=value1
* log4php.appender.appenderName.optionN=valueN
* </pre>
*
* For each named appender you can configure its {@link LoggerLayout}. The
* syntax for configuring an appender's layout is:
* <pre>
* log4php.appender.appenderName.layout=name_of_layout_class
* log4php.appender.appenderName.layout.option1=value1
* ....
* log4php.appender.appenderName.layout.optionN=valueN
* </pre>
*
* <p><b>Configuring loggers</b></p>
*
* <p>The syntax for configuring the root logger is:
* <pre>
* log4php.rootLogger=[level], appenderName, appenderName, ...
* </pre>
*
* <p>This syntax means that an optional <i>level</i> can be
* supplied followed by appender names separated by commas.
*
* <p>The level value can consist of the string values OFF, FATAL,
* ERROR, WARN, INFO, DEBUG, ALL or a <i>custom level</i> value. A
* custom level value can be specified in the form</p>
*
* <pre>level#classname</pre>
*
* <p>If a level value is specified, then the root level is set
* to the corresponding level. If no level value is specified,
* then the root level remains untouched.
*
* <p>The root logger can be assigned multiple appenders.
*
* <p>Each <i>appenderName</i> (separated by commas) will be added to
* the root logger. The named appender is defined using the
* appender syntax defined above.
*
* <p>For non-root categories the syntax is almost the same:
* <pre>
* log4php.logger.logger_name=[level|INHERITED|NULL], appenderName, appenderName, ...
* </pre>
*
* <p>The meaning of the optional level value is discussed above
* in relation to the root logger. In addition however, the value
* INHERITED can be specified meaning that the named logger should
* inherit its level from the logger hierarchy.</p>
*
* <p>If no level value is supplied, then the level of the
* named logger remains untouched.</p>
*
* <p>By default categories inherit their level from the
* hierarchy. However, if you set the level of a logger and later
* decide that that logger should inherit its level, then you should
* specify INHERITED as the value for the level value. NULL is a
* synonym for INHERITED.</p>
*
* <p>Similar to the root logger syntax, each <i>appenderName</i>
* (separated by commas) will be attached to the named logger.</p>
*
* <p>See the <i>appender additivity rule</i> in the user manual for
* the meaning of the <b>additivity</b> flag.
*
* <p><b>ObjectRenderers</b></p>
*
* <p>You can customize the way message objects of a given type are
* converted to String before being logged. This is done by
* specifying a {@link LoggerObjectRenderer}
* for the object type would like to customize.</p>
*
* <p>The syntax is:
*
* <pre>
* log4php.renderer.name_of_rendered_class=name_of_rendering.class
* </pre>
*
* As in,
* <pre>
* log4php.renderer.myFruit=myFruitRenderer
* </pre>
*
* <p><b>Logger Factories</b></p>
*
* The usage of custom logger factories is discouraged and no longer
* documented.
*
* <p><b>Example</b></p>
*
* <p>An example configuration is given below. Other configuration
* file examples are given in the <b>tests</b> folder.
*
* <pre>
* ; Set options for appender named "A1".
* ; Appender "A1" will be a SyslogAppender
* log4php.appender.A1=SyslogAppender
*
* ; The syslog daemon resides on www.abc.net
* log4php.appender.A1.SyslogHost=www.abc.net
*
* ; A1's layout is a LoggerPatternLayout, using the conversion pattern
* ; <b>%r %-5p %c{2} %M.%L %x - %m%n</b>. Thus, the log output will
* ; include the relative time since the start of the application in
* ; milliseconds, followed by the level of the log request,
* ; followed by the two rightmost components of the logger name,
* ; followed by the callers method name, followed by the line number,
* ; the nested disgnostic context and finally the message itself.
* ; Refer to the documentation of LoggerPatternLayout} for further information
* ; on the syntax of the ConversionPattern key.
* log4php.appender.A1.layout=LoggerPatternLayout
* log4php.appender.A1.layout.ConversionPattern="%-4r %-5p %c{2} %M.%L %x - %m%n"
*
* ; Set options for appender named "A2"
* ; A2 should be a LoggerAppenderRollingFile, with maximum file size of 10 MB
* ; using at most one backup file. A2's layout is TTCC, using the
* ; ISO8061 date format with context printing enabled.
* log4php.appender.A2=LoggerAppenderRollingFile
* log4php.appender.A2.MaxFileSize=10MB
* log4php.appender.A2.MaxBackupIndex=1
* log4php.appender.A2.layout=LoggerLayoutTTCC
* log4php.appender.A2.layout.ContextPrinting="true"
* log4php.appender.A2.layout.DateFormat="%c"
*
* ; Root logger set to DEBUG using the A2 appender defined above.
* log4php.rootLogger=DEBUG, A2
*
* ; Logger definitions:
* ; The SECURITY logger inherits is level from root. However, it's output
* ; will go to A1 appender defined above. It's additivity is non-cumulative.
* log4php.logger.SECURITY=INHERIT, A1
* log4php.additivity.SECURITY=false
*
* ; Only warnings or above will be logged for the logger "SECURITY.access".
* ; Output will go to A1.
* log4php.logger.SECURITY.access=WARN
*
*
* ; The logger "class.of.the.day" inherits its level from the
* ; logger hierarchy. Output will go to the appender's of the root
* ; logger, A2 in this case.
* log4php.logger.class.of.the.day=INHERIT
* </pre>
*
* <p>Refer to the <b>setOption</b> method in each Appender and
* Layout for class specific options.</p>
*
* <p>Use the <b>";"</b> character at the
* beginning of a line for comments.</p>
*
* @param string $url The name of the configuration file where the
* configuration information is stored.
* @param LoggerHierarchy &$repository the repository to apply the configuration
*/
function doConfigure($url, &$repository)
{
$properties = @parse_ini_file($url);
if ($properties === false) {
LoggerLog::warn("LoggerPropertyConfigurator::doConfigure() cannot load '$url' configuration.");
return false;
}
return $this->doConfigureProperties($properties, $repository);
}
/**
* Read configuration options from <b>properties</b>.
*
* @see doConfigure().
* @param array $properties
* @param LoggerHierarchy &$hierarchy
*/
function doConfigureProperties($properties, &$hierarchy)
{
if(array_key_exists(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_DEBUG_KEY, $properties))
$value = @$properties[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_DEBUG_KEY];
if (!empty($value)) {
LoggerLog::internalDebugging(LoggerOptionConverter::toBoolean($value, LoggerLog::internalDebugging()));
}
$thresholdStr = null;
if(array_key_exists(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_THRESHOLD_PREFIX, $properties))
$thresholdStr = @$properties[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_THRESHOLD_PREFIX];
$hierarchy->setThreshold(LoggerOptionConverter::toLevel($thresholdStr, LoggerLevel::getLevelAll()));
$this->configureRootCategory($properties, $hierarchy);
$this->configureLoggerFactory($properties);
$this->parseCatsAndRenderers($properties, $hierarchy);
LoggerLog::debug("LoggerPropertyConfigurator::doConfigureProperties() Finished configuring.");
return true;
}
// --------------------------------------------------------------------------
// Internal stuff
// --------------------------------------------------------------------------
/**
* Check the provided <b>Properties</b> object for a
* {@link LoggerFactory} entry specified by
* {@link LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_FACTORY_KEY}.
*
* If such an entry exists, an attempt is made to create an instance using
* the default constructor.
* This instance is used for subsequent Category creations
* within this configurator.
*
* @see parseCatsAndRenderers()
* @param array $props array of properties
*/
function configureLoggerFactory($props)
{
if(array_key_exists(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_FACTORY_KEY, $props))
$factoryFqcn = @$props[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_FACTORY_KEY];
if(!empty($factoryFqcn)) {
$factoryClassName = basename($factoryFqcn);
LoggerLog::debug(
"LoggerPropertyConfigurator::configureLoggerFactory() Trying to load factory [" .
$factoryClassName .
"]."
);
if (!class_exists($factoryClassName))
@include_once("{$factoryFqcn}.php");
if (class_exists($factoryClassName)) {
$loggerFactory = new $factoryClassName();
} else {
LoggerLog::debug(
"LoggerPropertyConfigurator::configureLoggerFactory() Unable to load factory [" .
$factoryClassName .
"]. Using default."
);
$loggerFactory = $this->loggerFactory;
}
LoggerLog::debug(
"LoggerPropertyConfigurator::configureLoggerFactory() ".
"Setting properties for category factory [" . get_class($loggerFactory) . "]."
);
LoggerPropertySetter::setPropertiesByObject($loggerFactory, $props, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_FACTORY_PREFIX . ".");
}
}
/**
* @param array $props array of properties
* @param LoggerHierarchy &$hierarchy
*/
function configureRootCategory($props, &$hierarchy)
{
$effectivePrefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_LOGGER_PREFIX;
$value = @$props[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_LOGGER_PREFIX];
if(empty($value)) {
$value = @$props[LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_CATEGORY_PREFIX];
$effectivePrefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ROOT_CATEGORY_PREFIX;
}
if (empty($value)) {
LoggerLog::debug(
"LoggerPropertyConfigurator::configureRootCategory() ".
"Could not find root logger information. Is this OK?"
);
} else {
$root =& $hierarchy->getRootLogger();
// synchronized(root) {
$this->parseCategory(
$props,
$root,
$effectivePrefix,
LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_INTERNAL_ROOT_NAME,
$value
);
// }
}
}
/**
* Parse non-root elements, such non-root categories and renderers.
*
* @param array $props array of properties
* @param LoggerHierarchy &$hierarchy
*/
function parseCatsAndRenderers($props, &$hierarchy)
{
while(list($key,$value) = each($props)) {
if( strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX) === 0 or
strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX) === 0) {
if(strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX) === 0) {
$loggerName = substr($key, strlen(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_CATEGORY_PREFIX));
} elseif (strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX) === 0) {
$loggerName = substr($key, strlen(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_LOGGER_PREFIX));
}
$logger =& $hierarchy->getLogger($loggerName, $this->loggerFactory);
// synchronized(logger) {
$this->parseCategory($props, $logger, $key, $loggerName, $value);
$this->parseAdditivityForLogger($props, $logger, $loggerName);
// }
} elseif (strpos($key, LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_RENDERER_PREFIX) === 0) {
$renderedClass = substr($key, strlen(LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_RENDERER_PREFIX));
$renderingClass = $value;
if (method_exists($hierarchy, 'addrenderer')) {
LoggerRendererMap::addRenderer($hierarchy, $renderedClass, $renderingClass);
}
}
}
}
/**
* Parse the additivity option for a non-root category.
*
* @param array $props array of properties
* @param Logger &$cat
* @param string $loggerName
*/
function parseAdditivityForLogger($props, &$cat, $loggerName)
{
$value = LoggerOptionConverter::findAndSubst(
LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ADDITIVITY_PREFIX . $loggerName,
$props
);
LoggerLog::debug(
"LoggerPropertyConfigurator::parseAdditivityForLogger() ".
"Handling " . LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_ADDITIVITY_PREFIX . $loggerName . "=[{$value}]"
);
// touch additivity only if necessary
if(!empty($value)) {
$additivity = LoggerOptionConverter::toBoolean($value, true);
LoggerLog::debug(
"LoggerPropertyConfigurator::parseAdditivityForLogger() ".
"Setting additivity for [{$loggerName}] to [{$additivity}]"
);
$cat->setAdditivity($additivity);
}
}
/**
* This method must work for the root category as well.
*
* @param array $props array of properties
* @param Logger &$logger
* @param string $optionKey
* @param string $loggerName
* @param string $value
* @return Logger
*/
function &parseCategory($props, &$logger, $optionKey, $loggerName, $value)
{
LoggerLog::debug(
"LoggerPropertyConfigurator::parseCategory() ".
"Parsing for [{$loggerName}] with value=[{$value}]."
);
// We must skip over ',' but not white space
$st = explode(',', $value);
// If value is not in the form ", appender.." or "", then we should set
// the level of the loggeregory.
if(!(@$value{0} == ',' || empty($value))) {
// just to be on the safe side...
if(sizeof($st) == 0)
return;
$levelStr = current($st);
LoggerLog::debug(
"LoggerPropertyConfigurator::parseCategory() ".
"Level token is [$levelStr]."
);
// If the level value is inherited, set category level value to
// null. We also check that the user has not specified inherited for the
// root category.
if('INHERITED' == strtoupper($levelStr) || 'NULL' == strtoupper($levelStr)) {
if ($loggerName == LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_INTERNAL_ROOT_NAME) {
LoggerLog::warn(
"LoggerPropertyConfigurator::parseCategory() ".
"The root logger cannot be set to null."
);
} else {
$logger->setLevel(null);
}
} else {
$logger->setLevel(LoggerOptionConverter::toLevel($levelStr, LoggerLevel::getLevelDebug()));
}
}
// Begin by removing all existing appenders.
$logger->removeAllAppenders();
while($appenderName = next($st)) {
$appenderName = trim($appenderName);
if(empty($appenderName))
continue;
LoggerLog::debug(
"LoggerPropertyConfigurator::parseCategory() ".
"Parsing appender named [{$appenderName}]."
);
$appender =& $this->parseAppender($props, $appenderName);
if($appender !== null) {
$logger->addAppender($appender);
}
}
}
/**
* @param array $props array of properties
* @param string $appenderName
* @return LoggerAppender
*/
function &parseAppender($props, $appenderName)
{
$appender =& LoggerAppender::singleton($appenderName);
if($appender !== null) {
LoggerLog::debug(
"LoggerPropertyConfigurator::parseAppender() ".
"Appender [{$appenderName}] was already parsed."
);
return $appender;
}
// Appender was not previously initialized.
$prefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_APPENDER_PREFIX . $appenderName;
$layoutPrefix = $prefix . ".layout";
$appenderClass = @$props[$prefix];
if (!empty($appenderClass)) {
$appender =& LoggerAppender::singleton($appenderName, $appenderClass);
if($appender === null) {
LoggerLog::warn(
"LoggerPropertyConfigurator::parseAppender() ".
"Could not instantiate appender named [$appenderName]."
);
return null;
}
} else {
LoggerLog::warn(
"LoggerPropertyConfigurator::parseAppender() ".
"Could not instantiate appender named [$appenderName] with null className."
);
return null;
}
$appender->setName($appenderName);
if( $appender->requiresLayout() ) {
LoggerLog::debug(
"LoggerPropertyConfigurator::parseAppender() ".
"Parsing layout section for [$appenderName]."
);
$layoutClass = @$props[$layoutPrefix];
$layoutClass = LoggerOptionConverter::substVars($layoutClass, $props);
if (empty($layoutClass)) {
LoggerLog::warn(
"LoggerPropertyConfigurator::parseAppender() ".
"layout class is empty in '$layoutPrefix'. Using Simple layout"
);
$layout = LoggerLayout::factory('LoggerLayoutSimple');
} else {
$layout = LoggerLayout::factory($layoutClass);
if($layout === null) {
LoggerLog::warn(
"LoggerPropertyConfigurator::parseAppender() ".
"cannot create layout '$layoutClass'. Using Simple layout"
);
$layout = LoggerLayout::factory('LoggerLayoutSimple');
}
}
LoggerLog::debug(
"LoggerPropertyConfigurator::parseAppender() ".
"Parsing layout options for [$appenderName]."
);
LoggerPropertySetter::setPropertiesByObject($layout, $props, $layoutPrefix . ".");
LoggerLog::debug(
"LoggerPropertyConfigurator::parseAppender() ".
"End Parsing layout options for [$appenderName]."
);
$appender->setLayout($layout);
}
LoggerPropertySetter::setPropertiesByObject($appender, $props, $prefix . ".");
LoggerLog::debug(
"LoggerPropertyConfigurator::parseAppender() ".
"Parsed [{$appenderName}] options."
);
return $appender;
}
}
?>