Subreality\Dilmun\Nabu\StaticLogger

Complexity

Total Complexity

11

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	setHandler()	0	4	1
A	log()	0	21	1
A	__callStatic()	0	14	2
A	validateLogLevel()	0	8	2
B	processContext()	0	26	3
A	checkContextException()	0	10	2

<?php
namespace Subreality\Dilmun\Nabu;

use \Subreality\Dilmun\Nabu\LoggerHandler\HandlerInterface as handler;

/**
 * Static logger framework that follows the PHP-FIG PSR-3 standard for logging.
 *
 * @see http://www.php-fig.org/psr/psr-3/
 *
 * @author Derek DeHart
 *
 * @todo Set minimum log level (e.g. log only notices and higher)
 * @todo Create handler stack to allow different logging mechanisms
 * @todo Specify different handlers for different log levels (e.g. file on info but file and email on alert)
 */
class StaticLogger
{
    const EMERGENCY = 'emergency';
    const ALERT = 'alert';
    const CRITICAL = 'critical';
    const ERROR = 'error';
    const WARNING = 'warning';
    const NOTICE = 'notice';
    const INFO = 'info';
    const DEBUG = 'debug';

    /**
     * @var handler
     */
    private static $handler;

    private static $valid_levels = array(
        "EMERGENCY",
        "ALERT",
        "CRITICAL",
        "ERROR",
        "WARNING",
        "NOTICE",
        "INFO",
        "DEBUG"
    );

    /**
     * Sets the handler (e.g. a File) to be used to log messages.
     *
     * @param handler $handler  The handler to be used to write a log message.
     */
    public static function setHandler(handler $handler)
    {
        self::$handler = $handler;
    }

    /**
     * @param string $level     Must contain a valid log level:
     *                              "emergency"
     *                              "alert"
     *                              "critical"
     *                              "error"
     *                              "warning"
     *                              "notice"
     *                              "info"
     *                              "debug"
     * @param string $message   Message to be logged
     * @param array $context    PSR-3 context for log entry
     *
     * @return string           Returns the log entry string.
     */
    public static function log($level, $message, array $context = array())
    {
        self::validateLogLevel($level);

        $u_level = strtoupper($level);

        $log_trace = debug_backtrace();

        $trace_origin = end($log_trace);

        $trace_line = $trace_origin["line"];
        $trace_file = $trace_origin["file"];

        $processed_message = self::processContext($message, $context);

        $log_entry = "$u_level: $trace_file, $trace_line: $processed_message";

        self::$handler->write($log_entry);

        return $log_entry;
    }

    /**
     * Generates a call to the log method given a supplied $level.
     *
     * @param string $level         Must contain a valid log level:
     *                                  "emergency"
     *                                  "alert"
     *                                  "critical"
     *                                  "error"
     *                                  "warning"
     *                                  "notice"
     *                                  "info"
     *                                  "debug"
     *                              Not specified inherently but rather derived from the overload.
     * @param array $log_arguments  The arguments passed to the log method by the __callStatic framework
     * @return string               The entry logged to the handler.
     *
     * @see StaticLogger::log
     * @see StaticLogger::validateLogLevel
     *
     * @todo Split out debug logging to provide more debugging information (vardumps, etc.)
     */
    public static function __callStatic($level, array $log_arguments)
    {
        self::validateLogLevel($level);

        //If there's only one argument passed to the logging function...
        if (count($log_arguments) == 1) {
            //Set the the second array element as an empty array.
            $log_arguments[1] = array();
        }

        $log_entry = self::log($level, $log_arguments[0], $log_arguments[1]);

        return $log_entry;
    }

    /**
     * Validates that a given $level is a valid PSR-3 log level
     *
     * @param string $level                 The log level being validated
     * @throws \InvalidArgumentException    Generates an Invalid Argument Exception if the supplied level is invalid
     *
     * @see StaticLogger::valid_levels
     */
    private static function validateLogLevel($level)
    {
        $u_level = strtoupper($level);

        if (!in_array($u_level, self::$valid_levels)) {
            throw new \InvalidArgumentException("Unknown log level");
        }
    }

    /**
     * Processes context as supplied by the log method, replacing templated strings with data from the context array
     * or processing exception data via checkContextException.
     *
     * Context array elements with the "exception" key are processed by pulling Exception line, file, and message into
     * the log message provided appropriate templates within the message: {line}, {file}, and {message}, respectively.
     * Note that any line, file, or message templates provided outside of an exception will be overwritten by context
     * processing, and so the order in which the context array data are stacked is relevant.
     *
     *
     *
     * @param string $message   The original log message to be processed with context.
     * @param array $context    An array of key => value pairs with additional data to be inserted into the log
     *                          message provided {templated text} (i.e. surrounded by curly braces.
     *
     * @return string           The processed log message
     *
     * @todo Determine if there are more relevant data in Exceptions to be used in templating.
     */
    private static function processContext($message, array $context = array())
    {
        $replace = array();

        foreach ($context as $key => $value) {
            $templated = "{" . $key . "}";
            $replace[$templated] = $value;
        }

        if (self::checkContextException($context)) {
            /**
             * @var \Exception $e
             */
            $e = $context["exception"];

            $e_line = $e->getLine();
            $e_file = $e->getFile();
            $e_message = $e->getMessage();

            $replace["{line}"] = $e_line;
            $replace["{file}"] = $e_file;
            $replace["{message}"] = $e_message;
        }

        return strtr($message, $replace);
    }

    /**
     * Determines whether a context array contains an Exception.
     *
     * @param array $context    PSR-3 context array.
     * @return bool             Returns true if the context array contains an element identified by an "exception" key
     *                          AND the value that corresponds with the "exception" key is an Exception.
     *                          Returns false otherwise.
     */
    private static function checkContextException(array $context = array())
    {
        if (isset($context["exception"])) {
            $includes_exception = $context["exception"] instanceof \Exception;
        } else {
            $includes_exception = false;
        }

        return $includes_exception;
    }
}