diff --git a/library/log4php/Logger.php b/library/log4php/Logger.php
new file mode 100644
--- /dev/null
+++ b/library/log4php/Logger.php
@@ -0,0 +1,596 @@
+<?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
+ */
+
+require dirname(__FILE__) . '/LoggerAutoloader.php';
+
+/**
+ * This is the central class in the log4php package. All logging operations
+ * are done through this class.
+ *
+ * The main logging methods are:
+ *    <ul>
+ *        <li>{@link trace()}</li>
+ *        <li>{@link debug()}</li>
+ *        <li>{@link info()}</li>
+ *        <li>{@link warn()}</li>
+ *        <li>{@link error()}</li>
+ *        <li>{@link fatal()}</li>
+ *    </ul>
+ *
+ * @package    log4php
+ * @license       http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
+ * @version       SVN: $Id: Logger.php 1395241 2012-10-07 08:28:53Z ihabunek $
+ * @link       http://logging.apache.org/log4php
+ */
+class Logger {
+
+    /**
+     * Logger additivity. If set to true then child loggers will inherit
+     * the appenders of their ancestors by default.
+     * @var boolean
+     */
+    private $additive = true;
+
+    /**
+     * The Logger's fully qualified class name.
+     * TODO: Determine if this is useful.
+     */
+    private $fqcn = 'Logger';
+
+    /** The assigned Logger level. */
+    private $level;
+
+    /** The name of this Logger instance. */
+    private $name;
+
+    /** The parent logger. Set to null if this is the root logger. */
+    private $parent;
+
+    /** A collection of appenders linked to this logger. */
+    private $appenders = array();
+
+    /**
+     * Constructor.
+     * @param string $name Name of the logger.
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+
+    /**
+     * Returns the logger name.
+     * @return string
+     */
+    public function getName() {
+        return $this->name;
+    }
+
+    /**
+     * Returns the parent Logger. Can be null if this is the root logger.
+     * @return Logger
+     */
+    public function getParent() {
+        return $this->parent;
+    }
+
+    // ******************************************
+    // *** Logging methods                    ***
+    // ******************************************
+
+    /**
+     * Log a message object with the TRACE level.
+     *
+     * @param mixed $message message
+     * @param Exception $throwable Optional throwable information to include
+     *   in the logging event.
+     */
+    public function trace($message, $throwable = null) {
+        $this->log(LoggerLevel::getLevelTrace(), $message, $throwable);
+    }
+
+    /**
+     * Log a message object with the DEBUG level.
+     *
+     * @param mixed $message message
+     * @param Exception $throwable Optional throwable information to include
+     *   in the logging event.
+     */
+    public function debug($message, $throwable = null) {
+        $this->log(LoggerLevel::getLevelDebug(), $message, $throwable);
+    }
+
+    /**
+     * Log a message object with the INFO Level.
+     *
+     * @param mixed $message message
+     * @param Exception $throwable Optional throwable information to include
+     *   in the logging event.
+     */
+    public function info($message, $throwable = null) {
+        $this->log(LoggerLevel::getLevelInfo(), $message, $throwable);
+    }
+
+    /**
+     * Log a message with the WARN level.
+     *
+     * @param mixed $message message
+     * @param Exception $throwable Optional throwable information to include
+     *   in the logging event.
+     */
+    public function warn($message, $throwable = null) {
+        $this->log(LoggerLevel::getLevelWarn(), $message, $throwable);
+    }
+
+    /**
+     * Log a message object with the ERROR level.
+     *
+     * @param mixed $message message
+     * @param Exception $throwable Optional throwable information to include
+     *   in the logging event.
+     */
+    public function error($message, $throwable = null) {
+        $this->log(LoggerLevel::getLevelError(), $message, $throwable);
+    }
+
+    /**
+     * Log a message object with the FATAL level.
+     *
+     * @param mixed $message message
+     * @param Exception $throwable Optional throwable information to include
+     *   in the logging event.
+     */
+    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)) {
+            $event = new LoggerLoggingEvent($this->fqcn, $this, $level, $message, null, $throwable);
+            $this->callAppenders($event);
+        }
+
+        // Forward the event upstream if additivity is turned on
+        if (isset($this->parent) && $this->getAdditivity()) {
+
+            // Use the event if already created
+            if (isset($event)) {
+                $this->parent->logEvent($event);
+            } else {
+                $this->parent->log($level, $message, $throwable);
+            }
+        }
+    }
+
+    /**
+     * Logs an already prepared logging event object.
+     * @param LoggerLoggingEvent $event
+     */
+    public function logEvent(LoggerLoggingEvent $event) {
+        if ($this->isEnabledFor($event->getLevel())) {
+            $this->callAppenders($event);
+        }
+
+        // Forward the event upstream if additivity is turned on
+        if (isset($this->parent) && $this->getAdditivity()) {
+            $this->parent->logEvent($event);
+        }
+    }
+
+    /**
+     * 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
+     * further checks.
+     *
+     * It should not be called directly. Use {@link trace()}, {@link debug()},
+     * {@link info()}, {@link warn()}, {@link error()} and {@link fatal()}
+     * wrappers.
+     *
+     * @param string $fqcn Fully qualified class name of the Logger
+     * @param Exception $throwable Optional throwable information to include
+     *   in the logging event.
+     * @param LoggerLevel $level log level
+     * @param mixed $message message to log
+     */
+    public function forcedLog($fqcn, $throwable, LoggerLevel $level, $message) {
+        $event = new LoggerLoggingEvent($fqcn, $this, $level, $message, null, $throwable);
+        $this->callAppenders($event);
+
+        // Forward the event upstream if additivity is turned on
+        if (isset($this->parent) && $this->getAdditivity()) {
+            $this->parent->logEvent($event);
+        }
+    }
+
+    /**
+     * Forwards the given logging event to all linked appenders.
+     * @param LoggerLoggingEvent $event
+     */
+    public function callAppenders($event) {
+        foreach ($this->appenders as $appender) {
+            $appender->doAppend($event);
+        }
+    }
+
+    // ******************************************
+    // *** Checker methods                    ***
+    // ******************************************
+
+    /**
+     * Check whether this Logger is enabled for a given Level passed as parameter.
+     *
+     * @param LoggerLevel level
+     * @return boolean
+     */
+    public function isEnabledFor(LoggerLevel $level) {
+        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.
+     * @return boolean
+     */
+    public function isInfoEnabled() {
+        return $this->isEnabledFor(LoggerLevel::getLevelInfo());
+    }
+
+    /**
+     * Check whether this Logger is enabled for the WARN Level.
+     * @return boolean
+     */
+    public function isWarnEnabled() {
+        return $this->isEnabledFor(LoggerLevel::getLevelWarn());
+    }
+
+    /**
+     * Check whether this Logger is enabled for the ERROR Level.
+     * @return boolean
+     */
+    public function isErrorEnabled() {
+        return $this->isEnabledFor(LoggerLevel::getLevelError());
+    }
+
+    /**
+     * Check whether this Logger is enabled for the FATAL Level.
+     * @return boolean
+     */
+    public function isFatalEnabled() {
+        return $this->isEnabledFor(LoggerLevel::getLevelFatal());
+    }
+
+    // ******************************************
+    // *** Configuration methods              ***
+    // ******************************************
+
+    /**
+     * Adds a new appender to the Logger.
+     * @param LoggerAppender $appender The appender to add.
+     */
+    public function addAppender($appender) {
+        $appenderName = $appender->getName();
+        $this->appenders[$appenderName] = $appender;
+    }
+
+    /** Removes all appenders from the Logger. */
+    public function removeAllAppenders() {
+        foreach ($this->appenders as $name => $appender) {
+            $this->removeAppender($name);
+        }
+    }
+
+    /**
+     * Remove the appender passed as parameter form the Logger.
+     * @param mixed $appender an appender name or a {@link LoggerAppender} instance.
+     */
+    public function removeAppender($appender) {
+        if ($appender instanceof LoggerAppender) {
+            $appender->close();
+            unset($this->appenders[$appender->getName()]);
+        } else if (is_string($appender) and isset($this->appenders[$appender])) {
+            $this->appenders[$appender]->close();
+            unset($this->appenders[$appender]);
+        }
+    }
+
+    /**
+     * Returns the appenders linked to this logger as an array.
+     * @return array collection of appender names
+     */
+    public function getAllAppenders() {
+        return $this->appenders;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Returns the additivity flag.
+     * @return boolean
+     */
+    public function getAdditivity() {
+        return $this->additive;
+    }
+
+    /**
+     * Starting from this Logger, search the Logger hierarchy for a non-null level and return it.
+     * @see LoggerLevel
+     * @return LoggerLevel or null
+     */
+    public function getEffectiveLevel() {
+        for ($logger = $this; $logger !== null; $logger = $logger->getParent()) {
+            if ($logger->getLevel() !== null) {
+                return $logger->getLevel();
+            }
+        }
+    }
+
+    /**
+     * Get the assigned Logger level.
+     * @return LoggerLevel The assigned level or null if none is assigned.
+     */
+    public function getLevel() {
+        return $this->level;
+    }
+
+    /**
+     * Set the Logger level.
+     *
+     * Use LoggerLevel::getLevelXXX() methods to get a LoggerLevel object, e.g.
+     * <code>$logger->setLevel(LoggerLevel::getLevelInfo());</code>
+     *
+     * @param LoggerLevel $level The level to set, or NULL to clear the logger level.
+     */
+    public function setLevel(LoggerLevel $level = null) {
+        $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
+     */
+    public static function clear() {
+        return self::getHierarchy()->clear();
+    }
+
+    /**
+     * Destroy configurations for logger definitions
+     */
+    public static function resetConfiguration() {
+        self::getHierarchy()->resetConfiguration();
+        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();
+    }
+
+    /**
+     * check if a given logger exists.
+     *
+     * @param string $name logger name
+     * @return boolean
+     */
+    public static function exists($name) {
+        return self::getHierarchy()->exists($name);
+    }
+
+    /**
+     * Returns an array this whole Logger instances.
+     * @see Logger
+     * @return array
+     */
+    public static function getCurrentLoggers() {
+        return self::getHierarchy()->getCurrentLoggers();
+    }
+
+    /**
+     * Configures log4php.
+     *
+     * This method needs to be called before the first logging event has
+     * occured. If this method is not called before then the default
+     * configuration will be used.
+     *
+     * @param string|array $configuration Either a path to the configuration
+     *   file, or a configuration array.
+     *
+     * @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, $configurator = null) {
+        self::resetConfiguration();
+        $configurator = self::getConfigurator($configurator);
+        $configurator->configure(self::getHierarchy(), $configuration);
+        self::$initialized = true;
+    }
+
+    /**
+     * Creates a logger configurator instance based on the provided
+     * configurator class. If no class is given, returns an instance of
+     * the default configurator.
+     *
+     * @param string|LoggerConfigurator $configurator The configurator class
+     * or LoggerConfigurator instance.
+     */
+    private static function getConfigurator($configurator = null) {
+        if ($configurator === null) {
+            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();
+            }
+        }
+
+        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();
+            }
+
+            $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;
+        }
+
+        trigger_error("log4php: Invalid configurator specified. Expected either a string or a LoggerConfigurator instance. Reverting to default configurator.", E_USER_WARNING);
+        return new LoggerConfiguratorDefault();
+    }
+
+    /**
+     * Returns true if the log4php framework has been initialized.
+     * @return boolean
+     */
+    private static function isInitialized() {
+        return self::$initialized;
+    }
+}