diff --git a/libraries/log4php.debug/Logger.php b/libraries/log4php.debug/Logger.php
index 447fd79196341e3bb98b91990833636cd68bfc2b..26d22606697c7dcba62b7f37bc2f45f0bebff765 100644
--- a/libraries/log4php.debug/Logger.php
+++ b/libraries/log4php.debug/Logger.php
@@ -18,11 +18,7 @@
  * @package log4php
  */
 
-if (function_exists('__autoload')) {
-	trigger_error("log4php: It looks like your code is using an __autoload() function. log4php uses spl_autoload_register() which will bypass your __autoload() function and may break autoloading.", E_USER_WARNING);
-}
-
-spl_autoload_register(array('Logger', 'autoload'));
+require dirname(__FILE__) . '/LoggerAutoloader.php';
 
 /**
  * This is the central class in the log4php package. All logging operations 
@@ -40,92 +36,11 @@ spl_autoload_register(array('Logger', 'autoload'));
  * 
  * @package    log4php
  * @license	   http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
- * @version	   SVN: $Id: Logger.php 1213710 2011-12-13 14:30:50Z ihabunek $
+ * @version	   SVN: $Id: Logger.php 1241439 2012-02-07 12:17:21Z ihabunek $
  * @link	   http://logging.apache.org/log4php
  */
 class Logger {
-	private static $_classes = array(
-		'LoggerException' => '/LoggerException.php',
-		'LoggerHierarchy' => '/LoggerHierarchy.php',
-		'LoggerLayout' => '/LoggerLayout.php',
-		'LoggerLevel' => '/LoggerLevel.php',
-		'LoggerMDC' => '/LoggerMDC.php',
-		'LoggerNDC' => '/LoggerNDC.php',
-		'LoggerReflectionUtils' => '/LoggerReflectionUtils.php',
-		'LoggerConfigurable' => '/LoggerConfigurable.php',
-		'LoggerConfigurator' => '/LoggerConfigurator.php',
-		'LoggerConfiguratorDefault' => '/configurators/LoggerConfiguratorDefault.php',
-		'LoggerConfigurationAdapter' => '/configurators/LoggerConfigurationAdapter.php',
-		'LoggerConfigurationAdapterINI' => '/configurators/LoggerConfigurationAdapterINI.php',
-		'LoggerConfigurationAdapterXML' => '/configurators/LoggerConfigurationAdapterXML.php',
-		'LoggerConfigurationAdapterPHP' => '/configurators/LoggerConfigurationAdapterPHP.php',
-		'LoggerRoot' => '/LoggerRoot.php',
-		'LoggerAppender' => '/LoggerAppender.php',
-		'LoggerAppenderPool' => '/LoggerAppenderPool.php',
-		'LoggerAppenderPDO' => '/appenders/LoggerAppenderPDO.php',
-		'LoggerAppenderConsole' => '/appenders/LoggerAppenderConsole.php',
-		'LoggerAppenderDailyFile' => '/appenders/LoggerAppenderDailyFile.php',
-		'LoggerAppenderEcho' => '/appenders/LoggerAppenderEcho.php',
-		'LoggerAppenderFile' => '/appenders/LoggerAppenderFile.php',
-		'LoggerAppenderMail' => '/appenders/LoggerAppenderMail.php',
-		'LoggerAppenderMailEvent' => '/appenders/LoggerAppenderMailEvent.php',
-		'LoggerAppenderMongoDB' => '/appenders/LoggerAppenderMongoDB.php',
-		'LoggerAppenderNull' => '/appenders/LoggerAppenderNull.php',
-		'LoggerAppenderPhp' => '/appenders/LoggerAppenderPhp.php',
-		'LoggerAppenderRollingFile' => '/appenders/LoggerAppenderRollingFile.php',
-		'LoggerAppenderSocket' => '/appenders/LoggerAppenderSocket.php',
-		'LoggerAppenderSyslog' => '/appenders/LoggerAppenderSyslog.php',
-		'LoggerFormattingInfo' => '/helpers/LoggerFormattingInfo.php',
-		'LoggerOptionConverter' => '/helpers/LoggerOptionConverter.php',
-		'LoggerPatternConverter' => '/helpers/LoggerPatternConverter.php',
-		'LoggerBasicPatternConverter' => '/helpers/LoggerBasicPatternConverter.php',
-		'LoggerCategoryPatternConverter' => '/helpers/LoggerCategoryPatternConverter.php',
-		'LoggerClassNamePatternConverter' => '/helpers/LoggerClassNamePatternConverter.php',
-		'LoggerDatePatternConverter' => '/helpers/LoggerDatePatternConverter.php',
-		'LoggerLiteralPatternConverter' => '/helpers/LoggerLiteralPatternConverter.php',
-		'LoggerLocationPatternConverter' => '/helpers/LoggerLocationPatternConverter.php',
-		'LoggerMDCPatternConverter' => '/helpers/LoggerMDCPatternConverter.php',
-		'LoggerNamedPatternConverter' => '/helpers/LoggerNamedPatternConverter.php',
-		'LoggerBasicPatternConverter' => '/helpers/LoggerBasicPatternConverter.php',
-		'LoggerLiteralPatternConverter' => '/helpers/LoggerLiteralPatternConverter.php',
-		'LoggerDatePatternConverter' => '/helpers/LoggerDatePatternConverter.php',
-		'LoggerMDCPatternConverter' => '/helpers/LoggerMDCPatternConverter.php',
-		'LoggerLocationPatternConverter' => '/helpers/LoggerLocationPatternConverter.php',
-		'LoggerNamedPatternConverter' => '/helpers/LoggerNamedPatternConverter.php',
-		'LoggerClassNamePatternConverter' => '/helpers/LoggerClassNamePatternConverter.php',
-		'LoggerCategoryPatternConverter' => '/helpers/LoggerCategoryPatternConverter.php',
-		'LoggerPatternParser' => '/helpers/LoggerPatternParser.php',
-		'LoggerLayoutHtml' => '/layouts/LoggerLayoutHtml.php',
-		'LoggerLayoutSimple' => '/layouts/LoggerLayoutSimple.php',
-		'LoggerLayoutTTCC' => '/layouts/LoggerLayoutTTCC.php',
-		'LoggerLayoutPattern' => '/layouts/LoggerLayoutPattern.php',
-		'LoggerLayoutSerialized' => '/layouts/LoggerLayoutSerialized.php',
-		'LoggerLayoutXml' => '/layouts/LoggerLayoutXml.php',
-		'LoggerRendererDefault' => '/renderers/LoggerRendererDefault.php',
-		'LoggerRendererObject' => '/renderers/LoggerRendererObject.php',
-		'LoggerRendererMap' => '/renderers/LoggerRendererMap.php',
-		'LoggerRendererException' => '/renderers/LoggerRendererException.php',
-		'LoggerLocationInfo' => '/LoggerLocationInfo.php',
-		'LoggerThrowableInformation' => '/LoggerThrowableInformation.php',
-		'LoggerLoggingEvent' => '/LoggerLoggingEvent.php',
-		'LoggerFilter' => '/LoggerFilter.php',
-		'LoggerFilterDenyAll' => '/filters/LoggerFilterDenyAll.php',
-		'LoggerFilterLevelMatch' => '/filters/LoggerFilterLevelMatch.php',
-		'LoggerFilterLevelRange' => '/filters/LoggerFilterLevelRange.php',
-		'LoggerFilterStringMatch' => '/filters/LoggerFilterStringMatch.php'
-	);
-
-	/**
-	 * Class autoloader. This method is provided to be invoked within an 
-	 * __autoload() magic method.
-	 * @param string $className The name of the class to load.
-	 */
-	public static function autoload($className) {
-		if(isset(self::$_classes[$className])) {
-			include dirname(__FILE__) . self::$_classes[$className];
-		}
-	}
-
+	
 	/**
 	 * Logger additivity. If set to true then child loggers will inherit
 	 * the appenders of their ancestors by default.
@@ -133,7 +48,10 @@ class Logger {
 	 */
 	private $additive = true;
 	
-	/** The Logger's fully qualified class name. */
+	/** 
+	 * The Logger's fully qualified class name.
+	 * TODO: Determine if this is useful. 
+	 */
 	private $fqcn = 'Logger';
 
 	/** The assigned Logger level. */
@@ -145,24 +63,9 @@ class Logger {
 	/** The parent logger. Set to null if this is the root logger. */
 	private $parent;
 	
-	/**
-	 * A collection of appenders associated with this logger.
-	 * @see LoggerAppender
-	 */
+	/** A collection of appenders linked to this logger. */
 	private $appenders = array();
 
-	/** The logger hierarchy used by log4php. */
-	private static $hierarchy;
-	
-	/** 
-	 * Holds the configurator. 
-	 * @var LoggerConfigurator 
-	 */
-	private static $configurator;
-	
-	/** Inidicates if log4php has been initialized */
-	private static $initialized = false;
-	
 	/**
 	 * Constructor.
 	 * @param string $name Name of the logger.	  
@@ -187,23 +90,10 @@ class Logger {
 		return $this->parent;
 	}
 	
-	/**
-	 * Returns the hierarchy used by this Logger.
-	 * Caution: do not use this hierarchy unless you have called initialize().
-	 * To get Loggers, use the Logger::getLogger and Logger::getRootLogger methods
-	 * instead of operating on on the hierarchy directly.
-	 * 
-	 * @deprecated - will be moved to private
-	 * @return LoggerHierarchy
-	 */
-	public static function getHierarchy() {
-		if(!isset(self::$hierarchy)) {
-			self::$hierarchy = new LoggerHierarchy(new LoggerRoot());
-		}
-		return self::$hierarchy;
-	}
+	// ******************************************
+	// *** Logging methods                    ***
+	// ******************************************
 	
-	/* Logging methods */
 	/**
 	 * Log a message object with the TRACE level.
 	 *
@@ -226,7 +116,6 @@ class Logger {
 		$this->log(LoggerLevel::getLevelDebug(), $message, $throwable);
 	} 
 
-
 	/**
 	 * Log a message object with the INFO Level.
 	 *
@@ -270,6 +159,33 @@ class Logger {
 	public function fatal($message, $throwable = null) {
 		$this->log(LoggerLevel::getLevelFatal(), $message, $throwable);
 	}
+
+	/**
+	 * Log a message using the provided logging level.
+	 *
+	 * @param LoggerLevel $level The logging level.
+	 * @param mixed $message Message to log.
+ 	 * @param Exception $throwable Optional throwable information to include 
+	 *   in the logging event.
+	 */
+	public function log(LoggerLevel $level, $message, $throwable = null) {
+		if($this->isEnabledFor($level)) {
+			$this->forcedLog($this->fqcn, $throwable, $level, $message);
+		}
+	}
+	
+	/**
+	 * If assertion parameter evaluates as false, then logs the message 
+	 * using the ERROR level.
+	 *
+	 * @param bool $assertion
+	 * @param string $msg message to log
+	 */
+	public function assertLog($assertion = true, $msg = '') {
+		if($assertion == false) {
+			$this->error($msg);
+		}
+	}
 	
 	/**
 	 * This method creates a new logging event and logs the event without 
@@ -286,20 +202,16 @@ class Logger {
 	 * @param mixed $message message to log
 	 */
 	public function forcedLog($fqcn, $throwable, LoggerLevel $level, $message) {
-		$throwable = ($throwable !== null && $throwable instanceof Exception) ? $throwable : null;
-		
+		if (!($throwable instanceof Exception)) {
+			$throwable = null;
+		}
 		$this->callAppenders(new LoggerLoggingEvent($fqcn, $this, $level, $message, null, $throwable));
 	} 
 	
+	// ******************************************
+	// *** Checker methods                    ***
+	// ******************************************
 	
-	/**
-	 * Check whether this Logger is enabled for the DEBUG Level.
-	 * @return boolean
-	 */
-	public function isDebugEnabled() {
-		return $this->isEnabledFor(LoggerLevel::getLevelDebug());
-	}		
-
 	/**
 	 * Check whether this Logger is enabled for a given Level passed as parameter.
 	 *
@@ -307,8 +219,24 @@ class Logger {
 	 * @return boolean
 	 */
 	public function isEnabledFor(LoggerLevel $level) {
-		return (bool)($level->isGreaterOrEqual($this->getEffectiveLevel()));
-	} 
+		return $level->isGreaterOrEqual($this->getEffectiveLevel());
+	}
+	
+	/**
+	 * Check whether this Logger is enabled for the TRACE Level.
+	 * @return boolean
+	 */
+	public function isTraceEnabled() {
+		return $this->isEnabledFor(LoggerLevel::getLevelTrace());
+	}
+	
+	/**
+	 * Check whether this Logger is enabled for the DEBUG Level.
+	 * @return boolean
+	 */
+	public function isDebugEnabled() {
+		return $this->isEnabledFor(LoggerLevel::getLevelDebug());
+	}
 
 	/**
 	 * Check whether this Logger is enabled for the INFO Level.
@@ -316,67 +244,38 @@ class Logger {
 	 */
 	public function isInfoEnabled() {
 		return $this->isEnabledFor(LoggerLevel::getLevelInfo());
-	} 
-
-	/**
-	 * Log a message using the provided logging level.
-	 *
-	 * @param LoggerLevel $level The logging level.
-	 * @param mixed $message Message to log.
- 	 * @param Exception $throwable Optional throwable information to include 
-	 *   in the logging event.
-	 */
-	public function log(LoggerLevel $level, $message, $throwable = null) {
-		if($this->isEnabledFor($level)) {
-			$this->forcedLog($this->fqcn, $throwable, $level, $message);
-		}
 	}
 	
 	/**
-	 * If assertion parameter is false, then logs the message as an error.
-	 *
-	 * @param bool $assertion
-	 * @param string $msg message to log
+	 * Check whether this Logger is enabled for the WARN Level.
+	 * @return boolean
 	 */
-	public function assertLog($assertion = true, $msg = '') {
-		if($assertion == false) {
-			$this->error($msg);
-		}
+	public function isWarnEnabled() {
+		return $this->isEnabledFor(LoggerLevel::getLevelWarn());
 	}
 	
-	/* Factory methods */ 
-	
 	/**
-	 * Returns a Logger by name. 
-	 * 
-	 * If it does not exist, it will be created.
-	 * 
-	 * @param string $name logger name
-	 * @return Logger
+	 * Check whether this Logger is enabled for the ERROR Level.
+	 * @return boolean
 	 */
-	public static function getLogger($name) {
-		if(!self::isInitialized()) {
-			self::configure();
-		}
-		return self::getHierarchy()->getLogger($name);
+	public function isErrorEnabled() {
+		return $this->isEnabledFor(LoggerLevel::getLevelError());
 	}
 	
 	/**
-	 * Returns the Root Logger.
-	 * @return LoggerRoot
-	 */	   
-	public static function getRootLogger() {
-		if(!self::isInitialized()) {
-			self::configure();
-		}
-		return self::getHierarchy()->getRootLogger();	  
+	 * Check whether this Logger is enabled for the FATAL Level.
+	 * @return boolean
+	 */
+	public function isFatalEnabled() {
+		return $this->isEnabledFor(LoggerLevel::getLevelFatal());
 	}
 	
-	/* Configuration methods */
+	// ******************************************
+	// *** Configuration methods              ***
+	// ******************************************
 	
 	/**
-	 * Add a new appender to the Logger.
-	 *
+	 * Adds a new appender to the Logger.
 	 * @param LoggerAppender $appender The appender to add.
 	 */
 	public function addAppender($appender) {
@@ -384,9 +283,7 @@ class Logger {
 		$this->appenders[$appenderName] = $appender;
 	}
 	
-	/**
-	 * Remove all previously added appenders from the Logger.
-	 */
+	/** Removes all appenders from the Logger. */
 	public function removeAllAppenders() {
 		foreach($this->appenders as $name => $appender) {
 			$this->removeAppender($name);
@@ -395,8 +292,7 @@ class Logger {
 			
 	/**
 	 * Remove the appender passed as parameter form the Logger.
-	 *
-	 * @param string|LoggerAppender $appender an appender name or a {@link LoggerAppender} instance.
+	 * @param mixed $appender an appender name or a {@link LoggerAppender} instance.
 	 */
 	public function removeAppender($appender) {
 		if($appender instanceof LoggerAppender) {
@@ -406,42 +302,50 @@ class Logger {
 			$this->appenders[$appender]->close();
 			unset($this->appenders[$appender]);
 		}
-	} 
-			
+	}
+	
 	/**
-	 * Forwards the given logging event to all appenders associated with the 
-	 * Logger.
-	 *
+	 * Forwards the given logging event to all linked appenders.
 	 * @param LoggerLoggingEvent $event 
 	 */
 	public function callAppenders($event) {
+		// Forward the event to each linked appender
 		foreach($this->appenders as $appender) {
 			$appender->doAppend($event);
 		}
 		
-		if($this->parent != null and $this->getAdditivity()) {
+		// Forward the event upstream if additivity is turned on
+		if(isset($this->parent) && $this->getAdditivity()) {
 			$this->parent->callAppenders($event);
 		}
 	}
 	
 	/**
-	 * Get the appenders contained in this logger as an array.
+	 * Returns the appenders linked to this logger as an array.
 	 * @return array collection of appender names
 	 */
 	public function getAllAppenders() {
-		return array_values($this->appenders);
+		return $this->appenders;
 	}
 	
 	/**
-	 * Get an appender by name.
+	 * Returns a linked appender by name.
 	 * @return LoggerAppender
 	 */
 	public function getAppender($name) {
 		return $this->appenders[$name];
 	}
+
+	/**
+	 * Sets the additivity flag.
+	 * @param boolean $additive
+	 */
+	public function setAdditivity($additive) {
+		$this->additive = (bool)$additive;
+	}
 	
 	/**
-	 * Get the additivity flag.
+	 * Returns the additivity flag.
 	 * @return boolean
 	 */
 	public function getAdditivity() {
@@ -454,12 +358,11 @@ class Logger {
 	 * @return LoggerLevel or null
 	 */
 	public function getEffectiveLevel() {
-		for($c = $this; $c != null; $c = $c->parent) {
-			if($c->getLevel() !== null) {
-				return $c->getLevel();
+		for($logger = $this; $logger !== null; $logger = $logger->getParent()) {
+			if($logger->getLevel() !== null) {
+				return $logger->getLevel();
 			}
 		}
-		return null;
 	}
   
 	/**
@@ -479,12 +382,81 @@ class Logger {
 		$this->level = $level;
 	}
 	
+	/**
+	 * Checks whether an appender is attached to this logger instance.
+	 *
+	 * @param LoggerAppender $appender
+	 * @return boolean
+	 */
+	public function isAttached(LoggerAppender $appender) {
+		return isset($this->appenders[$appender->getName()]);
+	} 
+		   
+
+	/**
+	 * Sets the parent logger.
+	 * @param Logger $logger
+	 */
+	public function setParent(Logger $logger) {
+		$this->parent = $logger;
+	} 
+	
+	// ******************************************
+	// *** Static methods and properties      ***
+	// ******************************************
+	
+	/** The logger hierarchy used by log4php. */
+	private static $hierarchy;
+	
+	/** Inidicates if log4php has been initialized */
+	private static $initialized = false;
+	
+	/**
+	 * Returns the hierarchy used by this Logger.
+	 *
+	 * Caution: do not use this hierarchy unless you have called initialize().
+	 * To get Loggers, use the Logger::getLogger and Logger::getRootLogger
+	 * methods instead of operating on on the hierarchy directly.
+	 *
+	 * @return LoggerHierarchy
+	 */
+	public static function getHierarchy() {
+		if(!isset(self::$hierarchy)) {
+			self::$hierarchy = new LoggerHierarchy(new LoggerRoot());
+		}
+		return self::$hierarchy;
+	}
+	
+	/**
+	 * Returns a Logger by name. If it does not exist, it will be created.
+	 *
+	 * @param string $name The logger name
+	 * @return Logger
+	 */
+	public static function getLogger($name) {
+		if(!self::isInitialized()) {
+			self::configure();
+		}
+		return self::getHierarchy()->getLogger($name);
+	}
+	
+	/**
+	 * Returns the Root Logger.
+	 * @return LoggerRoot
+	 */
+	public static function getRootLogger() {
+		if(!self::isInitialized()) {
+			self::configure();
+		}
+		return self::getHierarchy()->getRootLogger();
+	}
+	
 	/**
 	 * Clears all Logger definitions from the logger hierarchy.
-	 * @return boolean 
+	 * @return boolean
 	 */
 	public static function clear() {
-		return self::getHierarchy()->clear();	 
+		return self::getHierarchy()->clear();
 	}
 	
 	/**
@@ -495,20 +467,20 @@ class Logger {
 		self::getHierarchy()->clear(); // TODO: clear or not?
 		self::$initialized = false;
 	}
-
+	
 	/**
 	 * Safely close all appenders.
 	 * @deprecated This is no longer necessary due the appenders shutdown via
 	 * destructors.
 	 */
 	public static function shutdown() {
-		return self::getHierarchy()->shutdown();	   
+		return self::getHierarchy()->shutdown();
 	}
 	
 	/**
 	 * check if a given logger exists.
-	 * 
-	 * @param string $name logger name 
+	 *
+	 * @param string $name logger name
 	 * @return boolean
 	 */
 	public static function exists($name) {
@@ -524,32 +496,6 @@ class Logger {
 		return self::getHierarchy()->getCurrentLoggers();
 	}
 	
-	/**
-	 * Checks whether an appender is attached to this logger instance.
-	 *
-	 * @param LoggerAppender $appender
-	 * @return boolean
-	 */
-	public function isAttached(LoggerAppender $appender) {
-		return isset($this->appenders[$appender->getName()]);
-	} 
-		   
-	/**
-	 * Sets the additivity flag.
-	 * @param boolean $additive
-	 */
-	public function setAdditivity($additive) {
-		$this->additive = (bool)$additive;
-	}
-
-	/**
-	 * Sets the parent logger.
-	 * @param Logger $logger
-	 */
-	public function setParent(Logger $logger) {
-		$this->parent = $logger;
-	} 
-	
 	/**
 	 * Configures log4php.
 	 * 
@@ -560,13 +506,14 @@ class Logger {
 	 * @param string|array $configuration Either a path to the configuration
 	 *   file, or a configuration array.
 	 *   
-	 * @param mixed $configuratorClass A custom configurator class: either a 
-	 * class name (string), or an object which implements LoggerConfigurator
-	 * interface. If left empty, the default configurator will be used. 
+	 * @param string|LoggerConfigurator $configurator A custom 
+	 * configurator class: either a class name (string), or an object which 
+	 * implements the LoggerConfigurator interface. If left empty, the default
+	 * configurator implementation will be used. 
 	 */
-	public static function configure($configuration = null, $configuratorClass = null) {
+	public static function configure($configuration = null, $configurator = null) {
 		self::resetConfiguration();
-		$configurator = self::getConfigurator($configuratorClass);
+		$configurator = self::getConfigurator($configurator);
 		$configurator->configure(self::getHierarchy(), $configuration);
 		self::$initialized = true;
 	}
@@ -576,26 +523,41 @@ class Logger {
 	 * configurator class. If no class is given, returns an instance of
 	 * the default configurator.
 	 * 
-	 * @param string $configuratorClass The configurator class.
+	 * @param string|LoggerConfigurator $configurator The configurator class 
+	 * or LoggerConfigurator instance.
 	 */
-	private static function getConfigurator($configuratorClass = null) {
-		if (empty($configuratorClass)) {
+	private static function getConfigurator($configurator = null) {
+		if ($configurator === null) {
 			return new LoggerConfiguratorDefault();
 		}
 		
-		if (!class_exists($configuratorClass)) {
-			$this->warn("Specified configurator class [$configuratorClass] does not exist. Reverting to default configurator.");
-			return new LoggerConfiguratorDefault();
+		if (is_object($configurator)) {
+			if ($configurator instanceof LoggerConfigurator) {
+				return $configurator;
+			} else {
+				trigger_error("log4php: Given configurator object [$configurator] does not implement the LoggerConfigurator interface. Reverting to default configurator.", E_USER_WARNING);
+				return new LoggerConfiguratorDefault();
+			}
 		}
 		
-		$configurator = new $configuratorClass();
+		if (is_string($configurator)) {
+			if (!class_exists($configurator)) {
+				trigger_error("log4php: Specified configurator class [$configurator] does not exist. Reverting to default configurator.", E_USER_WARNING);
+				return new LoggerConfiguratorDefault();
+			}
 			
-		if (!($configurator instanceof LoggerConfigurator)) {
-			$this->warn("Specified configurator class [$configuratorClass] does not implement the LoggerConfigurator interface. Reverting to default configurator.");
-			return new LoggerConfiguratorDefault();
+			$instance = new $configurator();
+				
+			if (!($instance instanceof LoggerConfigurator)) {
+				trigger_error("log4php: Specified configurator class [$configurator] does not implement the LoggerConfigurator interface. Reverting to default configurator.", E_USER_WARNING);
+				return new LoggerConfiguratorDefault();
+			}
+			
+			return $instance;
 		}
 		
-		return $configurator;
+		trigger_error("log4php: Invalid configurator specified. Expected either a string or a LoggerConfigurator instance. Reverting to default configurator.", E_USER_WARNING);
+		return new LoggerConfiguratorDefault();
 	}
 	
 	/**
diff --git a/libraries/log4php.debug/LoggerAppender.php b/libraries/log4php.debug/LoggerAppender.php
index 7498981a897cf847bdbdfcc6d9a621e44dd8d918..923fc751f8606fb27a5a9502f3480e93b8c5072d 100644
--- a/libraries/log4php.debug/LoggerAppender.php
+++ b/libraries/log4php.debug/LoggerAppender.php
@@ -7,7 +7,7 @@
  * (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  *
- *	7 http://www.apache.org/licenses/LICENSE-2.0
+ *		http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -21,7 +21,7 @@
 /**
  * Abstract class that defines output logs strategies.
  *
- * @version $Revision: 1213712 $
+ * @version $Revision: 1240469 $
  * @package log4php
  */
 abstract class LoggerAppender extends LoggerConfigurable {
diff --git a/libraries/log4php.debug/LoggerAutoloader.php b/libraries/log4php.debug/LoggerAutoloader.php
new file mode 100644
index 0000000000000000000000000000000000000000..225757cb85e76e3412145048c6e52d0ecef6a788
--- /dev/null
+++ b/libraries/log4php.debug/LoggerAutoloader.php
@@ -0,0 +1,125 @@
+<?php
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * 
+ *		http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * 
+ * @package log4php
+ */
+
+if (function_exists('__autoload')) {
+	trigger_error("log4php: It looks like your code is using an __autoload() function. log4php uses spl_autoload_register() which will bypass your __autoload() function and may break autoloading.", E_USER_WARNING);
+}
+
+spl_autoload_register(array('LoggerAutoloader', 'autoload'));
+
+/**
+ * Class autoloader.
+ * 
+ * @package log4php
+ * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
+ * @version $Revision$
+ */
+class LoggerAutoloader {
+	
+	/** Maps classnames to files containing the class. */
+	private static $classes = array(
+	
+		// Base
+		'LoggerAppender' => '/LoggerAppender.php',
+		'LoggerAppenderPool' => '/LoggerAppenderPool.php',
+		'LoggerConfigurable' => '/LoggerConfigurable.php',
+		'LoggerConfigurator' => '/LoggerConfigurator.php',
+		'LoggerException' => '/LoggerException.php',
+		'LoggerHierarchy' => '/LoggerHierarchy.php',
+		'LoggerLevel' => '/LoggerLevel.php',
+		'LoggerLocationInfo' => '/LoggerLocationInfo.php',
+		'LoggerLoggingEvent' => '/LoggerLoggingEvent.php',
+		'LoggerMDC' => '/LoggerMDC.php',
+		'LoggerNDC' => '/LoggerNDC.php',
+		'LoggerLayout' => '/LoggerLayout.php',
+		'LoggerReflectionUtils' => '/LoggerReflectionUtils.php',
+		'LoggerRoot' => '/LoggerRoot.php',
+		'LoggerThrowableInformation' => '/LoggerThrowableInformation.php',
+
+		// Appenders
+		'LoggerAppenderConsole' => '/appenders/LoggerAppenderConsole.php',
+		'LoggerAppenderDailyFile' => '/appenders/LoggerAppenderDailyFile.php',
+		'LoggerAppenderEcho' => '/appenders/LoggerAppenderEcho.php',
+		'LoggerAppenderFile' => '/appenders/LoggerAppenderFile.php',
+		'LoggerAppenderMail' => '/appenders/LoggerAppenderMail.php',
+		'LoggerAppenderMailEvent' => '/appenders/LoggerAppenderMailEvent.php',
+		'LoggerAppenderMongoDB' => '/appenders/LoggerAppenderMongoDB.php',
+		'LoggerAppenderNull' => '/appenders/LoggerAppenderNull.php',
+		'LoggerAppenderPDO' => '/appenders/LoggerAppenderPDO.php',
+		'LoggerAppenderPhp' => '/appenders/LoggerAppenderPhp.php',
+		'LoggerAppenderRollingFile' => '/appenders/LoggerAppenderRollingFile.php',
+		'LoggerAppenderSocket' => '/appenders/LoggerAppenderSocket.php',
+		'LoggerAppenderSyslog' => '/appenders/LoggerAppenderSyslog.php',
+		
+		// Configurators
+		'LoggerConfigurationAdapter' => '/configurators/LoggerConfigurationAdapter.php',
+		'LoggerConfigurationAdapterINI' => '/configurators/LoggerConfigurationAdapterINI.php',
+		'LoggerConfigurationAdapterPHP' => '/configurators/LoggerConfigurationAdapterPHP.php',
+		'LoggerConfigurationAdapterXML' => '/configurators/LoggerConfigurationAdapterXML.php',
+		'LoggerConfiguratorDefault' => '/configurators/LoggerConfiguratorDefault.php',
+
+		// Filters
+		'LoggerFilter' => '/LoggerFilter.php',
+		'LoggerFilterDenyAll' => '/filters/LoggerFilterDenyAll.php',
+		'LoggerFilterLevelMatch' => '/filters/LoggerFilterLevelMatch.php',
+		'LoggerFilterLevelRange' => '/filters/LoggerFilterLevelRange.php',
+		'LoggerFilterStringMatch' => '/filters/LoggerFilterStringMatch.php',
+
+		// Helpers
+		'LoggerFormattingInfo' => '/helpers/LoggerFormattingInfo.php',
+		'LoggerOptionConverter' => '/helpers/LoggerOptionConverter.php',
+		'LoggerPatternParser' => '/helpers/LoggerPatternParser.php',
+		
+		// Converters
+		'LoggerBasicPatternConverter' => '/helpers/LoggerBasicPatternConverter.php',
+		'LoggerCategoryPatternConverter' => '/helpers/LoggerCategoryPatternConverter.php',
+		'LoggerClassNamePatternConverter' => '/helpers/LoggerClassNamePatternConverter.php',
+		'LoggerDatePatternConverter' => '/helpers/LoggerDatePatternConverter.php',
+		'LoggerLiteralPatternConverter' => '/helpers/LoggerLiteralPatternConverter.php',
+		'LoggerLocationPatternConverter' => '/helpers/LoggerLocationPatternConverter.php',
+		'LoggerMDCPatternConverter' => '/helpers/LoggerMDCPatternConverter.php',
+		'LoggerNamedPatternConverter' => '/helpers/LoggerNamedPatternConverter.php',
+		'LoggerPatternConverter' => '/helpers/LoggerPatternConverter.php',
+
+		// Layouts
+		'LoggerLayoutHtml' => '/layouts/LoggerLayoutHtml.php',
+		'LoggerLayoutPattern' => '/layouts/LoggerLayoutPattern.php',
+		'LoggerLayoutSerialized' => '/layouts/LoggerLayoutSerialized.php',
+		'LoggerLayoutSimple' => '/layouts/LoggerLayoutSimple.php',
+		'LoggerLayoutTTCC' => '/layouts/LoggerLayoutTTCC.php',
+		'LoggerLayoutXml' => '/layouts/LoggerLayoutXml.php',
+		
+		// Renderers
+		'LoggerRendererDefault' => '/renderers/LoggerRendererDefault.php',
+		'LoggerRendererException' => '/renderers/LoggerRendererException.php',
+		'LoggerRendererMap' => '/renderers/LoggerRendererMap.php',
+		'LoggerRendererObject' => '/renderers/LoggerRendererObject.php',
+	);
+
+	/**
+	 * Loads a class.
+	 * @param string $className The name of the class to load.
+	 */
+	public static function autoload($className) {
+		if(isset(self::$classes[$className])) {
+			include dirname(__FILE__) . self::$classes[$className];
+		}
+	}
+}
diff --git a/libraries/log4php.debug/LoggerLevel.php b/libraries/log4php.debug/LoggerLevel.php
index c2d24e975b6624c251c5dcf283162a7712f1a8f9..a4238b6845ae5a803a35e4b6b3b198eb3b8962af 100644
--- a/libraries/log4php.debug/LoggerLevel.php
+++ b/libraries/log4php.debug/LoggerLevel.php
@@ -27,7 +27,7 @@
  * <p>The <i>LoggerLevel</i> class may be subclassed to define a larger
  * level set.</p>
  *
- * @version $Revision: 1212319 $
+ * @version $Revision: 1230524 $
  * @package log4php
  * @since 0.5
  */
@@ -42,23 +42,17 @@ class LoggerLevel {
 	const TRACE = 5000;
 	const ALL = -2147483647;
 
-	/**
-	 * TODO: check if still necessary or to be refactored 
-	 * @var integer
-	 */
+	/** Integer level value. */
 	private $level;
 	
-	/**
-	 * Contains a list of instantiated levels 
-	 */
+	/** Contains a list of instantiated levels. */
 	private static $levelMap;
 
-	/**
-	 * @var string
-	 */
+	/** String representation of the level. */
 	private $levelStr;
 
-	/**
+	/** 
+	 * Equivalent syslog level.
 	 * @var integer
 	 */
 	private $syslogEquivalent;
@@ -77,14 +71,14 @@ class LoggerLevel {
 	}
 
 	/**
-	 * Two priorities are equal if their level fields are equal.
+	 * Compares two logger levels.
 	 *
-	 * @param object $o
+	 * @param LoggerLevels $other
 	 * @return boolean 
 	 */
-	public function equals($o) {
-		if($o instanceof LoggerLevel) {
-			if($this->level == $o->level) {
+	public function equals($other) {
+		if($other instanceof LoggerLevel) {
+			if($this->level == $other->level) {
 				return true;
 			}
 		} else {
@@ -98,7 +92,7 @@ class LoggerLevel {
 	 */
 	public static function getLevelOff() {
 		if(!isset(self::$levelMap[LoggerLevel::OFF])) {
-			self::$levelMap[LoggerLevel::OFF] = new LoggerLevel(LoggerLevel::OFF, 'OFF', 0);
+			self::$levelMap[LoggerLevel::OFF] = new LoggerLevel(LoggerLevel::OFF, 'OFF', LOG_ALERT);
 		}
 		return self::$levelMap[LoggerLevel::OFF];
 	}
@@ -109,7 +103,7 @@ class LoggerLevel {
 	 */
 	public static function getLevelFatal() {
 		if(!isset(self::$levelMap[LoggerLevel::FATAL])) {
-			self::$levelMap[LoggerLevel::FATAL] = new LoggerLevel(LoggerLevel::FATAL, 'FATAL', 0);
+			self::$levelMap[LoggerLevel::FATAL] = new LoggerLevel(LoggerLevel::FATAL, 'FATAL', LOG_ALERT);
 		}
 		return self::$levelMap[LoggerLevel::FATAL];
 	}
@@ -120,7 +114,7 @@ class LoggerLevel {
 	 */
 	public static function getLevelError() {
 		if(!isset(self::$levelMap[LoggerLevel::ERROR])) {
-			self::$levelMap[LoggerLevel::ERROR] = new LoggerLevel(LoggerLevel::ERROR, 'ERROR', 3);
+			self::$levelMap[LoggerLevel::ERROR] = new LoggerLevel(LoggerLevel::ERROR, 'ERROR', LOG_ERR);
 		}
 		return self::$levelMap[LoggerLevel::ERROR];
 	}
@@ -131,7 +125,7 @@ class LoggerLevel {
 	 */
 	public static function getLevelWarn() {
 		if(!isset(self::$levelMap[LoggerLevel::WARN])) {
-			self::$levelMap[LoggerLevel::WARN] = new LoggerLevel(LoggerLevel::WARN, 'WARN', 4);
+			self::$levelMap[LoggerLevel::WARN] = new LoggerLevel(LoggerLevel::WARN, 'WARN', LOG_WARNING);
 		}
 		return self::$levelMap[LoggerLevel::WARN];
 	}
@@ -142,7 +136,7 @@ class LoggerLevel {
 	 */
 	public static function getLevelInfo() {
 		if(!isset(self::$levelMap[LoggerLevel::INFO])) {
-			self::$levelMap[LoggerLevel::INFO] = new LoggerLevel(LoggerLevel::INFO, 'INFO', 6);
+			self::$levelMap[LoggerLevel::INFO] = new LoggerLevel(LoggerLevel::INFO, 'INFO', LOG_INFO);
 		}
 		return self::$levelMap[LoggerLevel::INFO];
 	}
@@ -153,7 +147,7 @@ class LoggerLevel {
 	 */
 	public static function getLevelDebug() {
 		if(!isset(self::$levelMap[LoggerLevel::DEBUG])) {
-			self::$levelMap[LoggerLevel::DEBUG] = new LoggerLevel(LoggerLevel::DEBUG, 'DEBUG', 7);
+			self::$levelMap[LoggerLevel::DEBUG] = new LoggerLevel(LoggerLevel::DEBUG, 'DEBUG', LOG_DEBUG);
 		}
 		return self::$levelMap[LoggerLevel::DEBUG];
 	}
@@ -164,7 +158,7 @@ class LoggerLevel {
 	 */
 	public static function getLevelTrace() {
 		if(!isset(self::$levelMap[LoggerLevel::TRACE])) {
-			self::$levelMap[LoggerLevel::TRACE] = new LoggerLevel(LoggerLevel::TRACE, 'TRACE', 7);
+			self::$levelMap[LoggerLevel::TRACE] = new LoggerLevel(LoggerLevel::TRACE, 'TRACE', LOG_DEBUG);
 		}
 		return self::$levelMap[LoggerLevel::TRACE];
 	}	
@@ -175,7 +169,7 @@ class LoggerLevel {
 	 */
 	public static function getLevelAll() {
 		if(!isset(self::$levelMap[LoggerLevel::ALL])) {
-			self::$levelMap[LoggerLevel::ALL] = new LoggerLevel(LoggerLevel::ALL, 'ALL', 7);
+			self::$levelMap[LoggerLevel::ALL] = new LoggerLevel(LoggerLevel::ALL, 'ALL', LOG_DEBUG);
 		}
 		return self::$levelMap[LoggerLevel::ALL];
 	}
@@ -192,15 +186,12 @@ class LoggerLevel {
 	 * Returns <i>true</i> if this level has a higher or equal
 	 * level than the level passed as argument, <i>false</i>
 	 * otherwise.
-	 * 
-	 * <p>You should think twice before overriding the default
-	 * implementation of <i>isGreaterOrEqual</i> method.
 	 *
-	 * @param LoggerLevel $r
+	 * @param LoggerLevel $other
 	 * @return boolean
 	 */
-	public function isGreaterOrEqual($r) {
-		return $this->level >= $r->level;
+	public function isGreaterOrEqual($other) {
+		return $this->level >= $other->level;
 	}
 
 	/**
diff --git a/libraries/log4php.debug/LoggerLoggingEvent.php b/libraries/log4php.debug/LoggerLoggingEvent.php
index 7736a6cacd81de95d3fa2ee4bd9780ad08cf5ce4..7e38972e92f27163bcf371780cd045a132978287 100644
--- a/libraries/log4php.debug/LoggerLoggingEvent.php
+++ b/libraries/log4php.debug/LoggerLoggingEvent.php
@@ -21,7 +21,7 @@
 /**
  * The internal representation of logging event.
  *
- * @version $Revision: 1212773 $
+ * @version $Revision: 1222216 $
  * @package log4php
  */
 class LoggerLoggingEvent {
@@ -39,26 +39,23 @@ class LoggerLoggingEvent {
 	private $logger = null;
 	
 	/** 
-	* The category (logger) name.
-	* This field will be marked as private in future
-	* releases. Please do not access it directly. 
-	* Use the {@link getLoggerName()} method instead.
-	* @deprecated 
-	*/
+	 * The category (logger) name.
+	 * This field will be marked as private in future
+	 * releases. Please do not access it directly. 
+	 * Use the {@link getLoggerName()} method instead.
+	 * @deprecated 
+	 */
 	private $categoryName;
 	
 	/** 
-	* Level of logging event.
-	* <p> This field should not be accessed directly. You shoud use the
-	* {@link getLevel()} method instead.
-	*
-	* @deprecated
-	* @var LoggerLevel
-	*/
+	 * Level of the logging event.
+	 * @var LoggerLevel
+	 */
 	protected $level;
 	
 	/** 
-	 * @var string The nested diagnostic context (NDC) of logging event. 
+	 * The nested diagnostic context (NDC) of logging event.
+	 * @var string  
 	 */
 	private $ndc;
 	
@@ -118,7 +115,7 @@ class LoggerLoggingEvent {
 	/**
 	* Instantiate a LoggingEvent from the supplied parameters.
 	*
-	* <p>Except {@link $timeStamp} all the other fields of
+	* Except {@link $timeStamp} all the other fields of
 	* LoggerLoggingEvent are filled when actually needed.
 	*
 	* @param string $fqcn name of the caller class.
@@ -141,12 +138,7 @@ class LoggerLoggingEvent {
 		if($timeStamp !== null && is_float($timeStamp)) {
 			$this->timeStamp = $timeStamp;
 		} else {
-			if(function_exists('microtime')) {
-				// get microtime as float
-				$this->timeStamp = microtime(true);
-			} else {
-				$this->timeStamp = floatval(time());
-			}
+			$this->timeStamp = microtime(true);
 		}
 		
 		if ($throwable !== null && $throwable instanceof Exception) {
@@ -175,38 +167,34 @@ class LoggerLoggingEvent {
 		if($this->locationInfo === null) {
 
 			$locationInfo = array();
-
-			if(function_exists('debug_backtrace')) {
-				$trace = debug_backtrace();
-				$prevHop = null;
-				// make a downsearch to identify the caller
-				$hop = array_pop($trace);
-				while($hop !== null) {
-					if(isset($hop['class'])) {
-						// we are sometimes in functions = no class available: avoid php warning here
-						$className = strtolower($hop['class']);
-						if(!empty($className) and ($className == 'logger' or $className == 'loggercategory' or 
-							strtolower(get_parent_class($className)) == 'logger' or
-							strtolower(get_parent_class($className)) == 'loggercategory')) {
-							$locationInfo['line'] = $hop['line'];
-							$locationInfo['file'] = $hop['file'];
-							break;
-						}
+			$trace = debug_backtrace();
+			$prevHop = null;
+			// make a downsearch to identify the caller
+			$hop = array_pop($trace);
+			while($hop !== null) {
+				if(isset($hop['class'])) {
+					// we are sometimes in functions = no class available: avoid php warning here
+					$className = strtolower($hop['class']);
+					if(!empty($className) and ($className == 'logger' or 
+						strtolower(get_parent_class($className)) == 'logger')) {
+						$locationInfo['line'] = $hop['line'];
+						$locationInfo['file'] = $hop['file'];
+						break;
 					}
-					$prevHop = $hop;
-					$hop = array_pop($trace);
-				}
-				$locationInfo['class'] = isset($prevHop['class']) ? $prevHop['class'] : 'main';
-				if(isset($prevHop['function']) and
-					$prevHop['function'] !== 'include' and
-					$prevHop['function'] !== 'include_once' and
-					$prevHop['function'] !== 'require' and
-					$prevHop['function'] !== 'require_once') {
-	
-					$locationInfo['function'] = $prevHop['function'];
-				} else {
-					$locationInfo['function'] = 'main';
 				}
+				$prevHop = $hop;
+				$hop = array_pop($trace);
+			}
+			$locationInfo['class'] = isset($prevHop['class']) ? $prevHop['class'] : 'main';
+			if(isset($prevHop['function']) and
+				$prevHop['function'] !== 'include' and
+				$prevHop['function'] !== 'include_once' and
+				$prevHop['function'] !== 'require' and
+				$prevHop['function'] !== 'require_once') {
+
+				$locationInfo['function'] = $prevHop['function'];
+			} else {
+				$locationInfo['function'] = 'main';
 			}
 					 
 			$this->locationInfo = new LoggerLocationInfo($locationInfo, $this->fqcn);
@@ -288,14 +276,9 @@ class LoggerLoggingEvent {
 	public function getRenderedMessage() {
 		if($this->renderedMessage === null and $this->message !== null) {
 			if(is_string($this->message)) {
-					$this->renderedMessage = $this->message;
+				$this->renderedMessage = $this->message;
 			} else {
-				// $this->logger might be null or an instance of Logger or RootLogger
-				// But in contrast to log4j, in log4php there is only have one LoggerHierarchy so there is
-				// no need figure out which one is $this->logger part of.
-				// TODO: Logger::getHierarchy() is marked @deprecated!
-				$repository = Logger::getHierarchy();
-				$rendererMap = $repository->getRendererMap();
+				$rendererMap = Logger::getHierarchy()->getRendererMap();
 				$this->renderedMessage= $rendererMap->findAndRender($this->message);
 			}
 		}
@@ -303,18 +286,13 @@ class LoggerLoggingEvent {
 	}
 
 	/**
-	 * Returns the time when the application started, in seconds
-	 * elapsed since 01.01.1970 plus microseconds if available.
+	 * Returns the time when the application started, as a UNIX timestamp 
+	 * with microseconds.
 	 * @return float
 	 */
 	public static function getStartTime() {
 		if(!isset(self::$startTime)) {
-			if (function_exists('microtime')) {
-				// microtime as float
-				self::$startTime = microtime(true);
-			} else {
-				self::$startTime = floatval(time());
-			}
+			self::$startTime = microtime(true);
 		}
 		return self::$startTime; 
 	}
@@ -331,8 +309,8 @@ class LoggerLoggingEvent {
 	 * @return the time after event starttime when this event has occured
 	 */
 	public function getTime() {
-		$eventTime = (float)$this->getTimeStamp();
-		$eventStartTime = (float)LoggerLoggingEvent::getStartTime();
+		$eventTime = $this->getTimeStamp();
+		$eventStartTime = LoggerLoggingEvent::getStartTime();
 		return number_format(($eventTime - $eventStartTime) * 1000, 0, '', '');
 	}
 	
diff --git a/libraries/log4php.debug/appenders/LoggerAppenderMailEvent.php b/libraries/log4php.debug/appenders/LoggerAppenderMailEvent.php
index 34775b5ac21451e1ec174224cb9626e611250536..199de1a4bcf8dea2bacd2f146832504e0a30cf38 100644
--- a/libraries/log4php.debug/appenders/LoggerAppenderMailEvent.php
+++ b/libraries/log4php.debug/appenders/LoggerAppenderMailEvent.php
@@ -47,7 +47,7 @@
  *      Tue Sep  8 21:51:04 2009,120 [5485] FATAL root - Some critical message!
  * </pre>
  *
- * @version $Revision: 1213283 $
+ * @version $Revision: 1237433 $
  * @package log4php
  * @subpackage appenders
  */
@@ -82,16 +82,17 @@ class LoggerAppenderMailEvent extends LoggerAppender {
 	protected $dry = false;
 	
 	public function activateOptions() {
-		if (empty($this->layout)) {
-			throw new LoggerException("LoggerAppenderMailEvent requires layout!");
-		}
 		if (empty($this->to)) {
-			throw new LoggerException("LoggerAppenderMailEvent was initialized with empty 'from' ($this->from) or 'to' ($this->to) Adress!");
+			$this->warn("Required parameter 'to' not set. Closing appender.");
+			$this->close = true;
+			return;
 		}
 		
 		$sendmail_from = ini_get('sendmail_from');
 		if (empty($this->from) and empty($sendmail_from)) {
-			throw new LoggerException("LoggerAppenderMailEvent requires 'from' or on win32 at least the ini variable sendmail_from!");
+			$this->warn("Required parameter 'from' not set. Closing appender.");
+			$this->close = true;
+			return;
 		}
 		
 		$this->closed = false;
diff --git a/libraries/log4php.debug/appenders/LoggerAppenderMongoDB.php b/libraries/log4php.debug/appenders/LoggerAppenderMongoDB.php
index 401167bfd0113e75638731d5594d7bd3da7b69f8..e9e5117e8f74ed083880f432e8a93b922ee3b0ae 100644
--- a/libraries/log4php.debug/appenders/LoggerAppenderMongoDB.php
+++ b/libraries/log4php.debug/appenders/LoggerAppenderMongoDB.php
@@ -52,6 +52,9 @@ class LoggerAppenderMongoDB extends LoggerAppender {
 	/** Default value for {@link $collectionName} */
 	const DEFAULT_COLLECTION_NAME = 'logs';
 	
+	/** Default value for {@link $timeout} */
+	const DEFAULT_TIMEOUT_VALUE = 3000;
+	
 	// ******************************************
 	// ** Configurable parameters              **
 	// ******************************************
@@ -74,6 +77,9 @@ class LoggerAppenderMongoDB extends LoggerAppender {
 	/** Password used to connect to the database. */
 	protected $password;
 	
+	/** Timeout value used when connecting to the database (in milliseconds). */
+	protected $timeout;
+	
 	// ******************************************
 	// ** Member variables                     **
 	// ******************************************
@@ -105,6 +111,7 @@ class LoggerAppenderMongoDB extends LoggerAppender {
 		$this->port = self::DEFAULT_MONGO_PORT;
 		$this->databaseName = self::DEFAULT_DB_NAME;
 		$this->collectionName = self::DEFAULT_COLLECTION_NAME;
+		$this->timeout = self::DEFAULT_TIMEOUT_VALUE;
 	}
 	
 	/**
@@ -116,7 +123,7 @@ class LoggerAppenderMongoDB extends LoggerAppender {
 	 */
 	public function activateOptions() {
 		try {
-			$this->connection = new Mongo(sprintf('%s:%d', $this->host, $this->port));
+			$this->connection = new Mongo(sprintf('%s:%d', $this->host, $this->port), array("timeout" => $this->timeout));
 			$db	= $this->connection->selectDB($this->databaseName);
 			if ($this->userName !== null && $this->password !== null) {
 				$authResult = $db->authenticate($this->userName, $this->password);
@@ -279,6 +286,15 @@ class LoggerAppenderMongoDB extends LoggerAppender {
 		return $this->password;
 	}
 	
+	/** Sets the value of {@link $timeout} parameter. */
+	public function setTimeout($timeout) {
+		$this->setPositiveInteger('timeout', $timeout);
+	}
+
+	/** Returns the value of {@link $timeout} parameter. */
+	public function getTimeout() {
+		return $this->timeout;
+	}
 	/** 
 	 * Returns the mongodb connection.
 	 * @return Mongo
diff --git a/libraries/log4php.debug/appenders/LoggerAppenderSyslog.php b/libraries/log4php.debug/appenders/LoggerAppenderSyslog.php
index 7b7b5eb9cf616370a19865f580421b4d22e4df9c..1ae57bb3a9345269e7e7188700c0238bcabe0809 100644
--- a/libraries/log4php.debug/appenders/LoggerAppenderSyslog.php
+++ b/libraries/log4php.debug/appenders/LoggerAppenderSyslog.php
@@ -67,7 +67,7 @@
  *
  * {@example ../../examples/resources/appender_syslog.properties 18}
  *
- * @version $Revision: 1213283 $
+ * @version $Revision: 1230527 $
  * @package log4php
  * @subpackage appenders
  */ 
@@ -128,16 +128,6 @@ class LoggerAppenderSyslog extends LoggerAppender {
 	 * @var int
 	 */
 	private $intOption;
-	
-	/** Maps log4php levels to equivalent syslog priorities. */
-	private $levelMap = array(
-		LoggerLevel::TRACE => LOG_DEBUG,
-		LoggerLevel::DEBUG => LOG_DEBUG,
-		LoggerLevel::INFO  => LOG_INFO,
-		LoggerLevel::WARN  => LOG_WARNING,
-		LoggerLevel::ERROR => LOG_ERR,
-		LoggerLevel::FATAL => LOG_ALERT,
-	);
 
 	/**
 	 * Sets the {@link $ident}.
@@ -268,14 +258,7 @@ class LoggerAppenderSyslog extends LoggerAppender {
 		if($this->overridePriority) {
 			return $this->intPriority;
 		}
-		
-		$int = $level->toInt();
-		
-		if (isset($this->levelMap[$int])) {
-			return $this->levelMap[$int];
-		} else {
-			return LOG_DEBUG;
-		}
+		return $level->getSyslogEquivalent();
 	}
 	
 	/** Parses a syslog option string and returns the correspodning int value. */
diff --git a/libraries/log4php.debug/configurators/LoggerConfigurationAdapterINI.php b/libraries/log4php.debug/configurators/LoggerConfigurationAdapterINI.php
index bcee40ff9031d145477465a1d52f52c5e14baf2a..801e52ab59dcc971fcded49d3d71c7b531dd32f0 100644
--- a/libraries/log4php.debug/configurators/LoggerConfigurationAdapterINI.php
+++ b/libraries/log4php.debug/configurators/LoggerConfigurationAdapterINI.php
@@ -73,7 +73,7 @@ class LoggerConfigurationAdapterINI implements LoggerConfigurationAdapter {
 			throw new LoggerException("File [$url] does not exist.");
 		}
 		
-		$properties = @parse_ini_file($url, true, INI_SCANNER_RAW);
+		$properties = @parse_ini_file($url, true);
 		if ($properties === false) {
 			$error = error_get_last();
 			throw new LoggerException("Error parsing configuration file: {$error['message']}");
@@ -303,4 +303,4 @@ class LoggerConfigurationAdapterINI implements LoggerConfigurationAdapter {
 	
 }
 
-?>
\ No newline at end of file
+?>
diff --git a/libraries/log4php.debug/helpers/LoggerOptionConverter.php b/libraries/log4php.debug/helpers/LoggerOptionConverter.php
index b32007688c25668f6ec2634b9ba9a38e8ab4c453..c63dc9633b4e6f8eb17ff8408f72474e4904e61f 100644
--- a/libraries/log4php.debug/helpers/LoggerOptionConverter.php
+++ b/libraries/log4php.debug/helpers/LoggerOptionConverter.php
@@ -21,7 +21,7 @@
 /**
  * A convenience class to convert property values to specific types.
  *
- * @version $Revision: 1213283 $ 
+ * @version $Revision: 1237446 $ 
  * @package log4php
  * @subpackage helpers
  * @since 0.5
@@ -36,8 +36,14 @@ class LoggerOptionConverter {
 	/** String values which are converted to boolean TRUE. */
 	private static $trueValues = array('1', 'true', 'yes', 'on');
 	
-	/** String values which are converted to boolean FALSE. */
-	private static $falseValues = array('0', 'false', 'no', 'off');
+	/** 
+	 * String values which are converted to boolean FALSE.
+	 * 
+	 * Note that an empty string must convert to false, because 
+	 * parse_ini_file() which is used for parsing configuration 
+	 * converts the value _false_ to an empty string.
+	 */
+	private static $falseValues = array('0', 'false', 'no', 'off', '');
 	
 	/**
 	 * Read a predefined var.