/** * 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; }