/**
* Return the decision of this filter.
*
* @param Ideasa_Log4php_LoggerLoggingEvent $event
* @return integer
*/
public function decide(Ideasa_Log4php_LoggerLoggingEvent $event)
{
$level = $event->getLevel();
if ($this->levelMin !== null) {
if ($level->isGreaterOrEqual($this->levelMin) == false) {
// level of event is less than minimum
return Ideasa_Log4php_LoggerFilter::DENY;
}
}
if ($this->levelMax !== null) {
if ($level->toInt() > $this->levelMax->toInt()) {
// level of event is greater than maximum
// Alas, there is no Level.isGreater method. and using
// a combo of isGreaterOrEqual && !Equal seems worse than
// checking the int values of the level objects..
return Ideasa_Log4php_LoggerFilter::DENY;
}
}
if ($this->acceptOnMatch) {
// this filter set up to bypass later filters and always return
// accept if level in range
return Ideasa_Log4php_LoggerFilter::ACCEPT;
} else {
// event is ok for this filter; allow later filters to have a look..
return Ideasa_Log4php_LoggerFilter::NEUTRAL;
}
}
/**
* Constructor
*
* @param integer $level initial log level
*/
public function __construct($level = null)
{
parent::__construct('root');
if ($level == null) {
$level = Ideasa_Log4php_LoggerLevel::getLevelAll();
}
$this->setLevel($level);
}
/**
* Return the decision of this filter.
*
* Returns {@link Ideasa_Log4php_LoggerFilter::NEUTRAL} if the <b><var>LevelToMatch</var></b>
* option is not set or if there is not match. Otherwise, if there is a
* match, then the returned decision is {@link Ideasa_Log4php_LoggerFilter::ACCEPT} if the
* <b><var>AcceptOnMatch</var></b> property is set to <i>true</i>. The
* returned decision is {@link Ideasa_Log4php_LoggerFilter::DENY} if the
* <b><var>AcceptOnMatch</var></b> property is set to <i>false</i>.
*
* @param Ideasa_Log4php_LoggerLoggingEvent $event
* @return integer
*/
public function decide(Ideasa_Log4php_LoggerLoggingEvent $event)
{
if ($this->levelToMatch === null) {
return Ideasa_Log4php_LoggerFilter::NEUTRAL;
}
if ($this->levelToMatch->equals($event->getLevel())) {
return $this->acceptOnMatch ? Ideasa_Log4php_LoggerFilter::ACCEPT : Ideasa_Log4php_LoggerFilter::DENY;
} else {
return Ideasa_Log4php_LoggerFilter::NEUTRAL;
}
}
public function append(Ideasa_Log4php_LoggerLoggingEvent $event)
{
if ($this->layout !== null) {
$level = $event->getLevel();
if ($level->isGreaterOrEqual(Ideasa_Log4php_LoggerLevel::getLevelError())) {
trigger_error($this->layout->format($event), E_USER_ERROR);
} else {
if ($level->isGreaterOrEqual(Ideasa_Log4php_LoggerLevel::getLevelWarn())) {
trigger_error($this->layout->format($event), E_USER_WARNING);
} else {
trigger_error($this->layout->format($event), E_USER_NOTICE);
}
}
}
}
/**
* Check whether the message level is below the appender's threshold.
*
*
* If there is no threshold set, then the return value is always <i>true</i>.
* @param Ideasa_Log4php_LoggerLevel $level
* @return boolean true if priority is greater or equal than threshold
*/
public function isAsSevereAsThreshold($level)
{
if ($this->threshold === null) {
return true;
}
return $level->isGreaterOrEqual($this->getThreshold());
}
/**
* This method must work for the root category as well.
*
* @param array $props array of properties
* @param Ideasa_Log4php_Logger $logger
* @param string $optionKey
* @param string $loggerName
* @param string $value
* @return Ideasa_Log4php_Logger
*/
private function parseCategory($props, Ideasa_Log4php_Logger $logger, $optionKey, $loggerName, $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 (!(empty($value) || @$value[0] == ',')) {
// just to be on the safe side...
if (count($st) == 0) {
return;
}
$levelStr = current($st);
// 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 == self::INTERNAL_ROOT_NAME) {
// TODO: throw exception? "The root logger cannot be set to null."
} else {
$logger->setLevel(null);
}
} else {
$logger->setLevel(Ideasa_Log4php_Helpers_LoggerOptionConverter::toLevel($levelStr, Ideasa_Log4php_LoggerLevel::getLevelDebug()));
}
}
// TODO: removing should be done by the logger, if necessary and wanted
// $logger->removeAllAppenders();
while ($appenderName = next($st)) {
$appenderName = trim($appenderName);
if (empty($appenderName)) {
continue;
}
$appender = $this->parseAppender($props, $appenderName);
if ($appender !== null) {
$logger->addAppender($appender);
}
}
}
private function doConfigure($url, Ideasa_Log4php_LoggerHierarchy $hierarchy)
{
if (!is_array($url)) {
$config = (require $url);
} else {
$config = $url;
}
// set threshold
if (isset($config['threshold'])) {
$hierarchy->setThreshold(Ideasa_Log4php_Helpers_LoggerOptionConverter::toLevel($config['threshold'], Ideasa_Log4php_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 = Ideasa_Log4php_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 = 'Ideasa_Log4php_Layouts_LoggerLayoutSimple';
}
$layout = Ideasa_Log4php_LoggerReflectionUtils::createObject($layoutClass);
if ($layout === null) {
$layout = Ideasa_Log4php_LoggerReflectionUtils::createObject('Ideasa_Log4php_Layouts_LoggerLayoutSimple');
}
if (isset($appenderProperties['file']) && method_exists($appender, 'setFileName')) {
$appender->setFile($appenderProperties['file'], true);
}
if ($layout instanceof Ideasa_Log4php_Layouts_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 Ideasa_Log4php_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(Ideasa_Log4php_Helpers_LoggerOptionConverter::toLevel($config['rootLogger']['level'], Ideasa_Log4php_LoggerLevel::getLevelDebug()));
if (isset($config['rootLogger']['appenders'])) {
foreach ($config['rootLogger']['appenders'] as $appenderName) {
$appender = Ideasa_Log4php_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(Ideasa_Log4php_Helpers_LoggerOptionConverter::toLevel($loggerProperties['level'], Ideasa_Log4php_LoggerLevel::getLevelDebug()));
if (isset($loggerProperties['appenders'])) {
foreach ($loggerProperties['appenders'] as $appenderName) {
$appender = Ideasa_Log4php_LoggerAppenderPool::getAppenderFromPool($appenderName);
if ($appender !== null) {
$logger->addAppender($appender);
}
}
}
}
} else {
// TODO: throw exception
}
}
}
return true;
}
/**
* Check whether this Logger is enabled for the INFO Level.
* @return boolean
*/
public function isInfoEnabled()
{
return $this->isEnabledFor(Ideasa_Log4php_LoggerLevel::getLevelInfo());
}
/**
* Converts a standard or custom priority level to a Level
* object.
*
* <p> If <var>$value</var> is of form "<b>level#full_file_classname</b>",
* where <i>full_file_classname</i> means the class filename with path
* but without php extension, then the specified class' <i>toLevel()</i> method
* is called to process the specified level string; if no '#'
* character is present, then the default {@link Ideasa_Log4php_LoggerLevel}
* class is used to process the level value.</p>
*
* <p>As a special case, if the <var>$value</var> parameter is
* equal to the string "NULL", then the value <i>null</i> will
* be returned.</p>
*
* <p>If any error occurs while converting the value to a level,
* the <var>$defaultValue</var> parameter, which may be
* <i>null</i>, is returned.</p>
*
* <p>Case of <var>$value</var> is insignificant for the level level, but is
* significant for the class name part, if present.</p>
*
* @param string $value
* @param Ideasa_Log4php_LoggerLevel $defaultValue
* @return Ideasa_Log4php_LoggerLevel a {@link Ideasa_Log4php_LoggerLevel} or null
* @static
*/
public static function toLevel($value, $defaultValue)
{
if ($value === null) {
return $defaultValue;
}
$hashIndex = strpos($value, '#');
if ($hashIndex === false) {
if ("NULL" == strtoupper($value)) {
return null;
} else {
// no class name specified : use standard Level class
return Ideasa_Log4php_LoggerLevel::toLevel($value, $defaultValue);
}
}
$result = $defaultValue;
$clazz = substr($value, $hashIndex + 1);
$levelName = substr($value, 0, $hashIndex);
// This is degenerate case but you never know.
if ("NULL" == strtoupper($levelName)) {
return null;
}
$clazz = basename($clazz);
if (class_exists($clazz)) {
$result = @call_user_func(array($clazz, 'toLevel'), $levelName, $defaultValue);
if (!$result instanceof Ideasa_Log4php_LoggerLevel) {
$result = $defaultValue;
}
}
return $result;
}
public function append(Ideasa_Log4php_LoggerLoggingEvent $event)
{
if ($this->_option == NULL) {
$this->_option = LOG_PID | LOG_CONS;
}
$level = $event->getLevel();
if ($this->layout === null) {
$message = $event->getRenderedMessage();
} else {
$message = $this->layout->format($event);
}
// If the priority of a syslog message can be overridden by a value defined in the properties-file,
// use that value, else use the one that is defined in the code.
if (!$this->dry) {
// Attach the process ID to the message, use the facility defined in the .properties-file
openlog($this->_ident, $this->_option, $this->_facility);
if ($this->_overridePriority) {
syslog($this->_priority, $message);
} else {
if ($level->isGreaterOrEqual(Ideasa_Log4php_LoggerLevel::getLevelFatal())) {
syslog(LOG_ALERT, $message);
} else {
if ($level->isGreaterOrEqual(Ideasa_Log4php_LoggerLevel::getLevelError())) {
syslog(LOG_ERR, $message);
} else {
if ($level->isGreaterOrEqual(Ideasa_Log4php_LoggerLevel::getLevelWarn())) {
syslog(LOG_WARNING, $message);
} else {
if ($level->isGreaterOrEqual(Ideasa_Log4php_LoggerLevel::getLevelInfo())) {
syslog(LOG_INFO, $message);
} else {
if ($level->isGreaterOrEqual(Ideasa_Log4php_LoggerLevel::getLevelDebug())) {
syslog(LOG_DEBUG, $message);
} else {
if ($level->isGreaterOrEqual(Ideasa_Log4php_LoggerLevel::getLevelTrace())) {
syslog(LOG_DEBUG, $message);
// No trace level in syslog
}
}
}
}
}
}
}
closelog();
} else {
echo "DRY MODE OF SYSLOG APPENDER: " . $message;
}
}
/**
* Reset all values contained in this hierarchy instance to their
* default.
*
* This removes all appenders from all categories, sets
* the level of all non-root categories to <i>null</i>,
* sets their additivity flag to <i>true</i> and sets the level
* of the root logger to {@link LOGGER_LEVEL_DEBUG}. Moreover,
* message disabling is set its default "off" value.
*
* <p>Existing categories are not removed. They are just reset.
*
* <p>This method should be used sparingly and with care as it will
* block all logging until it is completed.</p>
*/
public function resetConfiguration()
{
$root = $this->getRootLogger();
$root->setLevel(Ideasa_Log4php_LoggerLevel::getLevelDebug());
$this->setThreshold(Ideasa_Log4php_LoggerLevel::getLevelAll());
$this->shutDown();
$loggers = $this->getCurrentLoggers();
$enumLoggers = count($loggers);
for ($i = 0; $i < $enumLoggers; $i++) {
$loggers[$i]->setLevel(null);
$loggers[$i]->setAdditivity(true);
$loggers[$i]->removeAllAppenders();
}
$this->rendererMap->clear();
Ideasa_Log4php_LoggerAppenderPool::clear();
}
/**
* @param Ideasa_Log4php_LoggerLoggingEvent $event
* @return string
*/
public function format(Ideasa_Log4php_LoggerLoggingEvent $event)
{
$sbuf = PHP_EOL . "<tr>" . PHP_EOL;
$sbuf .= "<td>";
$sbuf .= $event->getTime();
$sbuf .= "</td>" . PHP_EOL;
$sbuf .= "<td title=\"" . $event->getThreadName() . " thread\">";
$sbuf .= $event->getThreadName();
$sbuf .= "</td>" . PHP_EOL;
$sbuf .= "<td title=\"Level\">";
$level = $event->getLevel();
if ($level->equals(Ideasa_Log4php_LoggerLevel::getLevelDebug())) {
$sbuf .= "<font color=\"#339933\">{$level}</font>";
} else {
if ($level->equals(Ideasa_Log4php_LoggerLevel::getLevelWarn())) {
$sbuf .= "<font color=\"#993300\"><strong>{$level}</strong></font>";
} else {
$sbuf .= $level;
}
}
$sbuf .= "</td>" . PHP_EOL;
$sbuf .= "<td title=\"" . htmlentities($event->getLoggerName(), ENT_QUOTES) . " category\">";
$sbuf .= htmlentities($event->getLoggerName(), ENT_QUOTES);
$sbuf .= "</td>" . PHP_EOL;
if ($this->locationInfo) {
$locInfo = $event->getLocationInformation();
$sbuf .= "<td>";
$sbuf .= htmlentities($locInfo->getFileName(), ENT_QUOTES) . ':' . $locInfo->getLineNumber();
$sbuf .= "</td>" . PHP_EOL;
}
$sbuf .= "<td title=\"Message\">";
$sbuf .= htmlentities($event->getRenderedMessage(), ENT_QUOTES);
$sbuf .= "</td>" . PHP_EOL;
$sbuf .= "</tr>" . PHP_EOL;
if ($event->getNDC() != null) {
$sbuf .= "<tr><td bgcolor=\"#EEEEEE\" style=\"font-size : xx-small;\" colspan=\"6\" title=\"Nested Diagnostic Context\">";
$sbuf .= "NDC: " . htmlentities($event->getNDC(), ENT_QUOTES);
$sbuf .= "</td></tr>" . PHP_EOL;
}
return $sbuf;
}
