/** * @param string $l the level to match */ public function setLevelToMatch($l) { if ($l instanceof LoggerLevel) { $this->levelToMatch = $l; } else { $this->levelToMatch = LoggerOptionConverter::toLevel($l, null); } }
public function testToBoolean() { self::assertEquals(true, LoggerOptionConverter::toBoolean(null, true)); self::assertEquals(true, LoggerOptionConverter::toBoolean(null)); self::assertEquals(true, LoggerOptionConverter::toBoolean(true)); self::assertEquals(true, LoggerOptionConverter::toBoolean("1")); self::assertEquals(true, LoggerOptionConverter::toBoolean("true")); self::assertEquals(true, LoggerOptionConverter::toBoolean("on")); self::assertEquals(true, LoggerOptionConverter::toBoolean("yes")); self::assertEquals(false, LoggerOptionConverter::toBoolean(null, false)); self::assertEquals(false, LoggerOptionConverter::toBoolean(false)); self::assertEquals(false, LoggerOptionConverter::toBoolean("")); self::assertEquals(false, LoggerOptionConverter::toBoolean("0")); self::assertEquals(false, LoggerOptionConverter::toBoolean("false")); self::assertEquals(false, LoggerOptionConverter::toBoolean("off")); self::assertEquals(false, LoggerOptionConverter::toBoolean("no")); }
public function setProperties($properties, $prefix) { $len = strlen($prefix); while (list($key, ) = each($properties)) { if (strpos($key, $prefix) === 0) { if (strpos($key, '.', $len + 1) > 0) { continue; } $value = LoggerOptionConverter::findAndSubst($key, $properties); $key = substr($key, $len); if ($key == 'layout' and $this->obj instanceof LoggerAppender) { continue; } $this->setProperty($key, $value); } } $this->activate(); }
/** * @param array $props array of properties * @param string $appenderName * @return LoggerAppender */ private function parseAppender($props, $appenderName) { $appender = LoggerAppenderPool::getAppenderFromPool($appenderName); $prefix = self::APPENDER_PREFIX . $appenderName; if ($appender === null) { // Appender was not previously initialized. $appenderClass = @$props[$prefix]; $appender = LoggerAppenderPool::getAppenderFromPool($appenderName, $appenderClass); if ($appender === null) { return null; } } if ($appender->requiresLayout()) { $layoutPrefix = $prefix . ".layout"; $layoutClass = @$props[$layoutPrefix]; $layoutClass = LoggerOptionConverter::substVars($layoutClass, $props); if (empty($layoutClass)) { $layout = LoggerReflectionUtils::createObject('LoggerLayoutSimple'); } else { $layout = LoggerReflectionUtils::createObject($layoutClass); if ($layout === null) { $layout = LoggerReflectionUtils::createObject('LoggerLayoutSimple'); } } LoggerReflectionUtils::setPropertiesByObject($layout, $props, $layoutPrefix . "."); $appender->setLayout($layout); } LoggerReflectionUtils::setPropertiesByObject($appender, $props, $prefix . "."); return $appender; }
/** * Set the threshold level of this appender. * * @param mixed $threshold can be a {@link LoggerLevel} object or a string. * @see LoggerOptionConverter::toLevel() */ function setThreshold($threshold) { if (is_string($threshold)) { $this->threshold = LoggerOptionConverter::toLevel($threshold, null); } elseif (is_a($threshold, 'loggerlevel')) { $this->threshold = $threshold; } }
/** * @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; }
public static function substVars($val, $props = null) { $sbuf = ''; $i = 0; while (true) { $j = strpos($val, self::DELIM_START, $i); if ($j === false) { // no more variables if ($i == 0) { // this is a simple string return $val; } else { // add the tail string which contails no variables and return the result. $sbuf .= substr($val, $i); return $sbuf; } } else { $sbuf .= substr($val, $i, $j - $i); $k = strpos($val, self::DELIM_STOP, $j); if ($k === false) { // LoggerOptionConverter::substVars() has no closing brace. Opening brace return ''; } else { $j += self::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 + self::DELIM_STOP_LEN; } } } }
/** * @param string $l the level max to match */ function setLevelMax($l) { $this->levelMax = LoggerOptionConverter::toLevel($l, null); }
/** * Set the properites for the object that match the * <code>prefix</code> passed as parameter. * * @param array $properties An array containing keys and values. * @param string $prefix Only keys having the specified prefix will be set. */ function setProperties($properties, $prefix) { LoggerLog::debug("LoggerOptionConverter::setProperties():prefix=[{$prefix}]"); $len = strlen($prefix); while (list($key, ) = each($properties)) { if (strpos($key, $prefix) === 0) { if (strpos($key, '.', $len + 1) > 0) { continue; } $value = LoggerOptionConverter::findAndSubst($key, $properties); $key = substr($key, $len); if ($key == 'layout' && is_a($this->obj, 'loggerappender')) { continue; } $this->setProperty($key, $value); } } $this->activate(); }
/** * The <b>ContextPrinting</b> option specifies log output will include * the nested context information belonging to the current thread. * This is true by default. */ public function setContextPrinting($contextPrinting) { $this->contextPrinting = LoggerOptionConverter::toBoolean($contextPrinting); }
public function setHtmlLineBreaks($value) { $this->htmlLineBreaks = LoggerOptionConverter::toBoolean($value, false); }
public function testSubstituteVars() { $props['OTHER_CONSTANT'] = "OTHER"; $props['MY_CONSTANT'] = "TEST"; $props['NEXT_CONSTANT'] = "NEXT"; $result = LoggerOptionConverter::substVars('Value of key is ${MY_CONSTANT}.', $props); self::assertEquals('Value of key is TEST.', $result); $result = LoggerOptionConverter::substVars('Value of key is ${MY_CONSTANT} or ${OTHER_CONSTANT}.', $props); self::assertEquals('Value of key is TEST or OTHER.', $result); $result = LoggerOptionConverter::substVars('Value of key is ${MY_CONSTANT_CONSTANT}.', $props); self::assertEquals('Value of key is DEFINE.', $result); $result = LoggerOptionConverter::substVars('Value of key is ${MY_CONSTANT_CONSTANT} or ${MY_CONSTANT_CONSTANT_OTHER}.', $props); self::assertEquals('Value of key is DEFINE or DEFINE_OTHER.', $result); }
private function doConfigure($url, LoggerHierarchy $hierarchy) { $config = (require $url); // set threshold if (isset($config['threshold'])) { $hierarchy->setThreshold(LoggerOptionConverter::toLevel($config['threshold'], LoggerLevel::getLevelAll())); } // parse and create appenders if (isset($config['appenders'])) { foreach ($config['appenders'] as $appenderName => $appenderProperties) { $appender = LoggerAppenderPool::getAppenderFromPool($appenderName, $appenderProperties['class']); if ($appender->requiresLayout()) { if (isset($appenderProperties['layout'])) { if (isset($appenderProperties['layout']['class']) and !empty($appenderProperties['layout']['class'])) { $layoutClass = $appenderProperties['layout']['class']; } else { $layoutClass = 'LoggerLayoutSimple'; } $layout = LoggerReflectionUtils::createObject($layoutClass); if ($layout === null) { $layout = LoggerReflectionUtils::createObject('LoggerLayoutSimple'); } if ($layout instanceof LoggerLayoutPattern) { $layout->setConversionPattern($appenderProperties['layout']['conversionPattern']); } $appender->setLayout($layout); } else { // TODO: throw exception? } } } } // parse and create root logger if (isset($config['rootLogger'])) { $rootLogger = $hierarchy->getRootLogger(); if (isset($config['rootLogger']['level'])) { $rootLogger->setLevel(LoggerOptionConverter::toLevel($config['rootLogger']['level'], LoggerLevel::getLevelDebug())); if (isset($config['rootLogger']['appenders'])) { foreach ($config['rootLogger']['appenders'] as $appenderName) { $appender = LoggerAppenderPool::getAppenderFromPool($appenderName); if ($appender !== null) { $rootLogger->addAppender($appender); } } } } } // parse and create loggers if (isset($config['loggers'])) { foreach ($config['loggers'] as $loggerName => $loggerProperties) { if (is_string($loggerName)) { $logger = $hierarchy->getLogger($loggerName); if (isset($loggerProperties['level'])) { $logger->setLevel(LoggerOptionConverter::toLevel($loggerProperties['level'], LoggerLevel::getLevelDebug())); if (isset($loggerProperties['appenders'])) { foreach ($loggerProperties['appenders'] as $appenderName) { $appender = LoggerAppenderPool::getAppenderFromPool($appenderName); if ($appender !== null) { $logger->addAppender($appender); } } } } } else { // TODO: throw exception } } } return true; }
private function doConfigure($url, LoggerHierarchy $hierarchy) { if (!is_array($url)) { $config = (require $url); } else { $config = $url; } // set threshold if (isset($config['threshold'])) { $hierarchy->setThreshold(LoggerOptionConverter::toLevel($config['threshold'], LoggerLevel::getLevelAll())); } // add renderes if (isset($config['renderers'])) { foreach ($config['renderers'] as $renderedClass => $renderingClass) { $hierarchy->getRendererMap()->addRenderer($renderedClass, $renderingClass); } } // parse and create appenders if (isset($config['appenders'])) { foreach ($config['appenders'] as $appenderName => $appenderProperties) { $appender = LoggerAppenderPool::getAppenderFromPool($appenderName, $appenderProperties['class']); // unset so that the property wont be drawn up again unset($appenderProperties['class']); if ($appender->requiresLayout()) { if (isset($appenderProperties['layout'])) { if (isset($appenderProperties['layout']['class']) and !empty($appenderProperties['layout']['class'])) { $layoutClass = $appenderProperties['layout']['class']; } else { $layoutClass = 'LoggerLayoutSimple'; } $layout = LoggerReflectionUtils::createObject($layoutClass); if ($layout === null) { $layout = LoggerReflectionUtils::createObject('LoggerLayoutSimple'); } if (isset($appenderProperties['file']) && method_exists($appender, 'setFileName')) { $appender->setFile($appenderProperties['file'], true); } if ($layout instanceof LoggerLayoutPattern) { $layout->setConversionPattern($appenderProperties['layout']['conversionPattern']); } $appender->setLayout($layout); // unset so that the property wont be drawn up again unset($appenderProperties['layout']); } else { // TODO: throw exception? } } // set remaining properties and activate appender $setter = new LoggerReflectionUtils($appender); foreach ($appenderProperties as $key => $val) { $setter->setProperty($key, $val); } $setter->activate(); } } // parse and create root logger if (isset($config['rootLogger'])) { $rootLogger = $hierarchy->getRootLogger(); if (isset($config['rootLogger']['level'])) { $rootLogger->setLevel(LoggerOptionConverter::toLevel($config['rootLogger']['level'], LoggerLevel::getLevelDebug())); if (isset($config['rootLogger']['appenders'])) { foreach ($config['rootLogger']['appenders'] as $appenderName) { $appender = LoggerAppenderPool::getAppenderFromPool($appenderName); if ($appender !== null) { $rootLogger->addAppender($appender); } } } } } // parse and create loggers if (isset($config['loggers'])) { foreach ($config['loggers'] as $loggerName => $loggerProperties) { if (is_string($loggerName)) { $logger = $hierarchy->getLogger($loggerName); if (isset($loggerProperties['level'])) { $logger->setLevel(LoggerOptionConverter::toLevel($loggerProperties['level'], LoggerLevel::getLevelDebug())); if (isset($loggerProperties['appenders'])) { foreach ($loggerProperties['appenders'] as $appenderName) { $appender = LoggerAppenderPool::getAppenderFromPool($appenderName); if ($appender !== null) { $logger->addAppender($appender); } } } } } else { // TODO: throw exception } } } return true; }
function setCreateTable($flag) { $this->createTable = LoggerOptionConverter::toBoolean($flag, true); }
/** * 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; } } } }
} } // --------------------------------------------------------------------------- // --------------------------------------------------------------------------- // --------------------------------------------------------------------------- if (!defined('LOG4PHP_DEFAULT_INIT_OVERRIDE')) { if (isset($_ENV['log4php.defaultInitOverride'])) { /** * @ignore */ define('LOG4PHP_DEFAULT_INIT_OVERRIDE', LoggerOptionConverter::toBoolean($_ENV['log4php.defaultInitOverride'], false)); } elseif (isset($GLOBALS['log4php.defaultInitOverride'])) { /** * @ignore */ define('LOG4PHP_DEFAULT_INIT_OVERRIDE', LoggerOptionConverter::toBoolean($GLOBALS['log4php.defaultInitOverride'], false)); } else { /** * Controls init execution * * With this constant users can skip the default init procedure that is * called when this file is included. * * <p>If it is not user defined, log4php tries to autoconfigure using (in order):</p> * * - the <code>$_ENV['log4php.defaultInitOverride']</code> variable. * - the <code>$GLOBALS['log4php.defaultInitOverride']</code> global variable. * - defaults to <i>false</i> * * @var boolean */
private function subst($value) { return LoggerOptionConverter::substVars($value); }
/** * @param string $l the level to match */ function setLevelToMatch($l) { $this->levelToMatch = LoggerOptionConverter::toLevel($l, null); }
/** * @param mixed */ function setUseXml($flag) { $this->useXml = LoggerOptionConverter::toBoolean($flag, $this->getUseXml()); }
/** * Configures a logger. * * @param Logger $logger The logger to configure * @param array $config Logger configuration options. */ private function configureLogger(Logger $logger, $config) { $loggerName = $logger->getName(); // Set logger level if (isset($config['level'])) { $level = LoggerLevel::toLevel($config['level']); if (isset($level)) { $logger->setLevel($level); } else { $default = $logger->getLevel(); $this->warn("Invalid level value [{$config['level']}] specified for logger [{$loggerName}]. Ignoring level definition."); } } // Link appenders to logger if (isset($config['appenders'])) { foreach ($config['appenders'] as $appenderName) { if (isset($this->appenders[$appenderName])) { $logger->addAppender($this->appenders[$appenderName]); } else { $this->warn("Nonexistnant appender [{$appenderName}] linked to logger [{$loggerName}]."); } } } // Set logger additivity if (isset($config['additivity'])) { $additivity = LoggerOptionConverter::toBoolean($config['additivity'], null); if (is_bool($additivity)) { $logger->setAdditivity($additivity); } else { $this->warn("Invalid additivity value [{$config['additivity']}] specified for logger [{$loggerName}]. Ignoring additivity setting."); } } }
/** * Check that various boolean equivalents from ini file convert properly * to boolean. */ public function testBooleanValues() { $values = parse_ini_file(PHPUNIT_CONFIG_DIR . '/adapters/ini/values.ini'); $actual = LoggerOptionConverter::toBooleanEx($values['unquoted_true']); self::assertTrue($actual); $actual = LoggerOptionConverter::toBooleanEx($values['unquoted_yes']); self::assertTrue($actual); $actual = LoggerOptionConverter::toBooleanEx($values['unquoted_false']); self::assertFalse($actual); $actual = LoggerOptionConverter::toBooleanEx($values['unquoted_no']); self::assertFalse($actual); $actual = LoggerOptionConverter::toBooleanEx($values['quoted_true']); self::assertTrue($actual); $actual = LoggerOptionConverter::toBooleanEx($values['quoted_false']); self::assertFalse($actual); $actual = LoggerOptionConverter::toBooleanEx($values['unquoted_one']); self::assertTrue($actual); $actual = LoggerOptionConverter::toBooleanEx($values['unquoted_zero']); self::assertFalse($actual); }
function setAppend($flag) { $this->append = LoggerOptionConverter::toBoolean($flag, true); }
/** * Setter function for string type. */ protected function setString($property, $value, $nullable = false) { if ($value === null) { if ($nullable) { $this->{$property} = null; } else { $this->warn("Null value given for '{$property}' property. Expected a string. Property not changed."); } } else { try { $value = LoggerOptionConverter::toStringEx($value); $this->{$property} = LoggerOptionConverter::substConstants($value); } catch (Exception $ex) { $value = var_export($value, true); $this->warn("Invalid value given for '{$property}' property: [{$value}]. Expected a string. Property not changed."); } } }
/** * Set the threshold level of this appender. * * @param mixed $threshold can be a {@link LoggerLevel} object or a string. * @see LoggerOptionConverter::toLevel() */ public function setThreshold($threshold) { if (is_string($threshold)) { $this->threshold = LoggerOptionConverter::toLevel($threshold, null); } else { if ($threshold instanceof LoggerLevel) { $this->threshold = $threshold; } } }
/** * @param boolean */ public function setLog4jNamespace($flag) { $this->log4jNamespace = LoggerOptionConverter::toBoolean($flag, true); }
public function testSubstituteConstants() { define('OTHER_CONSTANT', 'OTHER'); define('MY_CONSTANT', 'TEST'); define('NEXT_CONSTANT', 'NEXT'); $result = LoggerOptionConverter::substConstants('Value of key is ${MY_CONSTANT}.'); self::assertEquals('Value of key is TEST.', $result); $result = LoggerOptionConverter::substConstants('Value of key is ${MY_CONSTANT} or ${OTHER_CONSTANT}.'); self::assertEquals('Value of key is TEST or OTHER.', $result); $result = LoggerOptionConverter::substConstants('Value of key is ${MY_CONSTANT_CONSTANT}.'); self::assertEquals('Value of key is DEFINE.', $result); $result = LoggerOptionConverter::substConstants('Value of key is ${MY_CONSTANT_CONSTANT} or ${MY_CONSTANT_CONSTANT_OTHER}.'); self::assertEquals('Value of key is DEFINE or DEFINE_OTHER.', $result); }