/**
* Add a renderer to a hierarchy passed as parameter.
* Note that hierarchy must implement getRendererMap() and setRenderer() methods.
*
* @param LoggerHierarchy $repository a logger repository.
* @param string $renderedClassName
* @param string $renderingClassName
* @static
*/
public static function addRenderer($repository, $renderedClassName, $renderingClassName)
{
LoggerLog::debug("LoggerRendererMap::addRenderer() Rendering class: [{$renderingClassName}], Rendered class: [{$renderedClassName}].");
$renderer = LoggerObjectRenderer::factory($renderingClassName);
if ($renderer == null) {
LoggerLog::warn("LoggerRendererMap::addRenderer() Could not instantiate renderer [{$renderingClassName}].");
return;
} else {
$repository->setRenderer($renderedClassName, $renderer);
}
}
/**
* @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;
}
/**
* @see LoggerAppender::setErrorHandler()
* @param object
*/
public function setErrorHandler($errorHandler)
{
if ($errorHandler == null) {
// We do not throw exception here since the cause is probably a
// bad config file.
LoggerLog::warn("You have tried to set a null error-handler.");
} else {
$this->errorHandler = $errorHandler;
}
}
/**
* Perform variable substitution in string <var>$val</var> from the
* values of keys found with the {@link getSystemProperty()} method.
*
* <p>The variable substitution delimeters are <b>${</b> and <b>}</b>.
*
* <p>For example, if the "MY_CONSTANT" contains "value", then
* the call
* <code>
* $s = LoggerOptionConverter::substituteVars("Value of key is ${MY_CONSTANT}.");
* </code>
* will set the variable <i>$s</i> to "Value of key is value.".</p>
*
* <p>If no value could be found for the specified key, then the
* <var>$props</var> parameter is searched, if the value could not
* be found there, then substitution defaults to the empty string.</p>
*
* <p>For example, if {@link getSystemProperty()} cannot find any value for the key
* "inexistentKey", then the call
* <code>
* $s = LoggerOptionConverter::substVars("Value of inexistentKey is [${inexistentKey}]");
* </code>
* will set <var>$s</var> to "Value of inexistentKey is []".</p>
*
* <p>A warn is thrown if <var>$val</var> contains a start delimeter "${"
* which is not balanced by a stop delimeter "}" and an empty string is returned.</p>
*
* @log4j-author Avy Sharell
*
* @param string $val The string on which variable substitution is performed.
* @param array $props
* @return string
*
* @static
*/
function substVars($val, $props = null)
{
LoggerLog::debug("LoggerOptionConverter::substVars():val=[{$val}]");
$sbuf = '';
$i = 0;
while (true) {
$j = strpos($val, LOG4PHP_OPTION_CONVERTER_DELIM_START, $i);
if ($j === false) {
LoggerLog::debug("LoggerOptionConverter::substVars() no more variables");
// no more variables
if ($i == 0) {
// this is a simple string
LoggerLog::debug("LoggerOptionConverter::substVars() simple string");
return $val;
} else {
// add the tail string which contails no variables and return the result.
$sbuf .= substr($val, $i);
LoggerLog::debug("LoggerOptionConverter::substVars():sbuf=[{$sbuf}]. Returning sbuf");
return $sbuf;
}
} else {
$sbuf .= substr($val, $i, $j - $i);
LoggerLog::debug("LoggerOptionConverter::substVars():sbuf=[{$sbuf}]:i={$i}:j={$j}.");
$k = strpos($val, LOG4PHP_OPTION_CONVERTER_DELIM_STOP, $j);
if ($k === false) {
LoggerLog::warn("LoggerOptionConverter::substVars() " . "'{$val}' has no closing brace. Opening brace at position {$j}.");
return '';
} else {
$j += LOG4PHP_OPTION_CONVERTER_DELIM_START_LEN;
$key = substr($val, $j, $k - $j);
// first try in System properties
$replacement = LoggerOptionConverter::getSystemProperty($key, null);
// then try props parameter
if ($replacement == null and $props !== null) {
$replacement = @$props[$key];
}
if (!empty($replacement)) {
// Do variable substitution on the replacement string
// such that we can solve "Hello ${x2}" as "Hello p1"
// the where the properties are
// x1=p1
// x2=${x1}
$recursiveReplacement = LoggerOptionConverter::substVars($replacement, $props);
$sbuf .= $recursiveReplacement;
}
$i = $k + LOG4PHP_OPTION_CONVERTER_DELIM_STOP_LEN;
}
}
}
}
/**
* Default init procedure.
*
* <p>This procedure tries to configure the {@link LoggerHierarchy} using the
* configurator class defined via {@link LOG4PHP_CONFIGURATOR_CLASS} that tries
* to load the configurator file defined in {@link LOG4PHP_CONFIGURATION}.
* If something goes wrong a warn is raised.</p>
* <p>Users can skip this procedure using {@link LOG4PHP_DEFAULT_INIT_OVERRIDE}
* constant.</p>
*
* @return boolean
*/
function LoggerManagerDefaultInit()
{
$configuratorClass = basename(LOG4PHP_CONFIGURATOR_CLASS);
if (!class_exists($configuratorClass)) {
@(include_once LOG4PHP_CONFIGURATOR_CLASS . ".php");
}
if (class_exists($configuratorClass)) {
return call_user_func(array($configuratorClass, 'configure'), LOG4PHP_CONFIGURATION);
} else {
LoggerLog::warn("LoggerManagerDefaultInit() Configurator '{$configuratorClass}' doesnt exists");
return false;
}
}
/**
* Set a property on this PropertySetter's Object. If successful, this
* method will invoke a setter method on the underlying Object. The
* setter is the one for the specified property name and the value is
* determined partly from the setter argument type and partly from the
* value specified in the call to this method.
*
* <p>If the setter expects a String no conversion is necessary.
* If it expects an int, then an attempt is made to convert 'value'
* to an int using new Integer(value). If the setter expects a boolean,
* the conversion is by new Boolean(value).
*
* @param string $name name of the property
* @param string $value String value of the property
*/
function setProperty($name, $value)
{
LoggerLog::debug("LoggerOptionConverter::setProperty():name=[{$name}]:value=[{$value}]");
if ($value === null) {
return;
}
$method = "set" . ucfirst($name);
if (!method_exists($this->obj, $method)) {
LoggerLog::warn("LoggerOptionConverter::setProperty() No such setter method for [{$name}] property in " . get_class($this->obj) . ".");
} else {
return call_user_func(array(&$this->obj, $method), $value);
}
}
/**
* @param object $object
* @param string $name
* @param mixed $value
*/
function setter(&$object, $name, $value)
{
if (empty($name)) {
LoggerLog::debug("LoggerDOMConfigurator::setter() 'name' param cannot be empty");
return false;
}
$methodName = 'set' . ucfirst($name);
if (method_exists($object, $methodName)) {
LoggerLog::debug("LoggerDOMConfigurator::setter() Calling " . get_class($object) . "::{$methodName}({$value})");
return call_user_func(array(&$object, $methodName), $value);
} else {
LoggerLog::warn("LoggerDOMConfigurator::setter() " . get_class($object) . "::{$methodName}() does not exists");
return false;
}
}
function finalizeConverter($c)
{
LoggerLog::debug("LoggerPatternParser::finalizeConverter() with char '{$c}'");
$pc = null;
switch ($c) {
case 'c':
$pc = new LoggerCategoryPatternConverter($this->formattingInfo, $this->extractPrecisionOption());
LoggerLog::debug("LoggerPatternParser::finalizeConverter() CATEGORY converter.");
// $this->formattingInfo->dump();
$this->currentLiteral = '';
break;
case 'C':
$pc = new LoggerClassNamePatternConverter($this->formattingInfo, $this->extractPrecisionOption());
LoggerLog::debug("LoggerPatternParser::finalizeConverter() CLASSNAME converter.");
//$this->formattingInfo->dump();
$this->currentLiteral = '';
break;
case 'd':
$dateFormatStr = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601;
// ISO8601_DATE_FORMAT;
$dOpt = $this->extractOption();
if ($dOpt !== null) {
$dateFormatStr = $dOpt;
}
if ($dateFormatStr == 'ISO8601') {
$df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601;
} elseif ($dateFormatStr == 'ABSOLUTE') {
$df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ABSOLUTE;
} elseif ($dateFormatStr == 'DATE') {
$df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_DATE;
} else {
$df = $dateFormatStr;
if ($df == null) {
$df = LOG4PHP_LOGGER_PATTERN_PARSER_DATE_FORMAT_ISO8601;
}
}
$pc = new LoggerDatePatternConverter($this->formattingInfo, $df);
$this->currentLiteral = '';
break;
case 'F':
$pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_FILE_LOCATION_CONVERTER);
LoggerLog::debug("LoggerPatternParser::finalizeConverter() File name converter.");
//formattingInfo.dump();
$this->currentLiteral = '';
break;
case 'l':
$pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER);
LoggerLog::debug("LoggerPatternParser::finalizeConverter() Location converter.");
//formattingInfo.dump();
$this->currentLiteral = '';
break;
case 'L':
$pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_LINE_LOCATION_CONVERTER);
LoggerLog::debug("LoggerPatternParser::finalizeConverter() LINE NUMBER converter.");
//formattingInfo.dump();
$this->currentLiteral = '';
break;
case 'm':
$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_MESSAGE_CONVERTER);
LoggerLog::debug("LoggerPatternParser::finalizeConverter() MESSAGE converter.");
//formattingInfo.dump();
$this->currentLiteral = '';
break;
case 'M':
$pc = new LoggerLocationPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER);
//LogLog.debug("METHOD converter.");
//formattingInfo.dump();
$this->currentLiteral = '';
break;
case 'p':
$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_LEVEL_CONVERTER);
//LogLog.debug("LEVEL converter.");
//formattingInfo.dump();
$this->currentLiteral = '';
break;
case 'r':
$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER);
LoggerLog::debug("LoggerPatternParser::finalizeConverter() RELATIVE TIME converter.");
//formattingInfo.dump();
$this->currentLiteral = '';
break;
case 't':
$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER);
LoggerLog::debug("LoggerPatternParser::finalizeConverter() THREAD converter.");
//formattingInfo.dump();
$this->currentLiteral = '';
break;
case 'u':
if ($this->i < $this->patternLength) {
$cNext = $this->pattern[$this->i];
if (ord($cNext) >= ord('0') && ord($cNext) <= ord('9')) {
$pc = new LoggerUserFieldPatternConverter($this->formattingInfo, (string) (ord($cNext) - ord('0')));
LoggerLog::debug("LoggerPatternParser::finalizeConverter() USER converter [{$cNext}].");
// formattingInfo.dump();
$this->currentLiteral = '';
$this->i++;
} else {
LoggerLog::warn("LoggerPatternParser::finalizeConverter() Unexpected char '{$cNext}' at position {$this->i}.");
}
}
break;
case 'x':
$pc = new LoggerBasicPatternConverter($this->formattingInfo, LOG4PHP_LOGGER_PATTERN_PARSER_NDC_CONVERTER);
LoggerLog::debug("LoggerPatternParser::finalizeConverter() NDC converter.");
$this->currentLiteral = '';
break;
case 'X':
$xOpt = $this->extractOption();
$pc = new LoggerMDCPatternConverter($this->formattingInfo, $xOpt);
LoggerLog::debug("LoggerPatternParser::finalizeConverter() MDC converter.");
$this->currentLiteral = '';
break;
default:
LoggerLog::warn("LoggerPatternParser::finalizeConverter() Unexpected char [{$c}] at position {$this->i} in conversion pattern.");
$pc = new LoggerLiteralPatternConverter($this->currentLiteral);
$this->currentLiteral = '';
}
$this->addConverter($pc);
}
/**
* @abstract
* @param string $name
* @return Logger
*/
function makeNewLoggerInstance($name)
{
LoggerLog::warn("LoggerFactory:: makeNewLoggerInstance() is abstract.");
return null;
}
