Apix\Log\Logger\AbstractLogger

Complexity

Total Complexity

21

Size/Duplication

Total Lines	258
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Test Coverage

Coverage

92.54%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	getLevelCode()	0	11	2
A	log()	0	6	1
A	process()	0	10	2
A	isHandling()	0	4	1
A	setMinLevel()	0	7	1
A	interceptAt()	0	4	1
A	getMinLevel()	0	4	1
A	setCascading()	0	6	1
A	setDeferred()	0	6	1
A	getDeferredLogs()	0	4	1
A	__destruct()	0	24	3
A	close()	0	4	1
A	setLogFormatter()	0	4	1
A	getLogFormatter()	0	8	2
A	setOptions()	0	6	2

<?php

/**
 * This file is part of the Apix Project.
 *
 * (c) Franck Cassedanne <franck at ouarz.net>
 *
 * @license http://opensource.org/licenses/BSD-3-Clause  New BSD License
 */

namespace Apix\Log\Logger;

use Psr\Log\AbstractLogger as PsrAbstractLogger;
use Psr\Log\InvalidArgumentException;
use Apix\Log\LogEntry;
use Apix\Log\LogFormatter;

/**
 * Abstratc class.
 *
 * @author Franck Cassedanne <franck at ouarz.net>
 */
abstract class AbstractLogger extends PsrAbstractLogger
{
    /**
     * The PSR-3 logging levels.
     * @var array
     */
    protected static $levels = array(
        'emergency',
        'alert',
        'critical',
        'error',
        'warning',
        'notice',
        'info',
        'debug'
    );

    /**
     * Holds the minimal level index supported by this logger.
     * @var int
     */
    protected $min_level = 7;

    /**
     * Whether this logger will cascade downstream.
     * @var bool
     */
    protected $cascading = true;

    /**
     * Whether this logger will be deferred (push the logs at destruct time).
     * @var bool
     */
    protected $deferred = false;

    /**
     * Holds the deferred logs.
     * @var array
     */
    protected $deferred_logs = array();

    /**
     * Holds the log formatter.
     * @var LogFormatter|null
     */
    protected $log_formatter = null;

    /**
     * Holds the logger options (useful to set default options).
     * @var array
     */
    protected $options = array();

    /**
     * Gets the named level code.
     *
     * @param  string $level_name The name of a PSR-3 level.
     * @return int
     * @throws InvalidArgumentException
     */
    public static function getLevelCode($level_name)
    {
        $level_code = array_search($level_name, static::$levels);
        if (false === $level_code) {
            throw new InvalidArgumentException(
                sprintf('Invalid log level "%s"', $level_name)
            );
        }

        return $level_code;
    }

    /**
     * {@inheritdoc}
     */
    public function log($level, $message, array $context = array())
    {
        $entry = new LogEntry($level, $message, $context);
        $entry->setFormatter($this->getLogFormatter());

It seems like $this->getLogFormatter() can be null; however, setFormatter() does not accept null, maybe add an additional type check?

        $this->process($entry);
    }

    /**
     * Processes the given log.
     *
     * @param  LogEntry $log The log entry to process.
     * @return bool Wether this logger cascade downstream.
     */
    public function process(LogEntry $log)
    {
        if ($this->deferred) {
            $this->deferred_logs[] = $log;
        } else {
            $this->write($log);

It seems like you code against a specific sub-type and not the parent class Apix\Log\Logger\AbstractLogger as the method write() does only exist in the following sub-classes of Apix\Log\Logger\AbstractLogger: Apix\Log\Logger\ErrorLog, Apix\Log\Logger\File, Apix\Log\Logger\Mail, Apix\Log\Logger\Nil, Apix\Log\Logger\Runtime, Apix\Log\Logger\Sapi, Apix\Log\Logger\Stream. Maybe you want to instanceof check for one of these explicitly?

        }

        return $this->cascading;
    }

    /**
     * Checks whether the given level code is handled by this logger.
     *
     * @param  int $level_code
     * @return bool
     */
    public function isHandling($level_code)
    {
        return $this->min_level >= $level_code;
    }

    /**
     * Sets the minimal level at which this logger will be triggered.
     *
     * @param  string    $name
     * @param  bool|true $cascading Should the logs continue pass that level.
     * @return self
     */
    public function setMinLevel($name, $cascading = true)
    {
        $this->min_level = self::getLevelCode(strtolower($name));

It seems like self::getLevelCode(strtolower($name)) can also be of type string. However, the property $min_level is declared as type integer. Maybe add an additional type check?

        $this->cascading = (boolean) $cascading;

        return $this;
    }

    /**
     * Alias to self::setMinLevel().
     *
     * @param  string    $name
     * @param  bool|false $blocking Should the logs continue pass that level.
     * @return self
     */
    public function interceptAt($name, $blocking = false)
    {
        return $this->setMinLevel($name, !$blocking);
    }

    /**
     * Returns the minimal level at which this logger will be triggered.
     *
     * @return int
     */
    public function getMinLevel()
    {
        return $this->min_level;
    }

    /**
     * Sets wether to enable/disable cascading.
     *
     * @param  bool $bool
     * @return self
     */
    public function setCascading($bool)
    {
        $this->cascading = (boolean) $bool;

        return $this;
    }

    /**
     * Sets wether to enable/disable log deferring.
     *
     * @param  bool $bool
     * @return self
     */
    public function setDeferred($bool)
    {
        $this->deferred = (boolean) $bool;

        return $this;
    }

    /**
     * Returns all the deferred logs.
     *
     * @return array
     */
    public function getDeferredLogs()
    {
        return $this->deferred_logs;
    }

    /**
     * Process any accumulated deferred log if there are any.
     */
    final public function __destruct()
    {
        if ($this->deferred && !empty($this->deferred_logs)) {

            $messages = array_map(
                function ($log) {
                    return (string) $log;
                },
                $this->deferred_logs
            );
            
            $formatter = $this->getLogFormatter();
            
            $messages = implode($formatter->separator, $messages);

            $entries = new LogEntry('notice', $messages);
            $entries->setFormatter( $formatter );
            $this->write($entries);

It seems like you code against a specific sub-type and not the parent class Apix\Log\Logger\AbstractLogger as the method write() does only exist in the following sub-classes of Apix\Log\Logger\AbstractLogger: Apix\Log\Logger\ErrorLog, Apix\Log\Logger\File, Apix\Log\Logger\Mail, Apix\Log\Logger\Nil, Apix\Log\Logger\Runtime, Apix\Log\Logger\Sapi, Apix\Log\Logger\Stream. Maybe you want to instanceof check for one of these explicitly?

            // return $this->formatter->format($this);
        }

        $this->close();
    }

    /**
     * Closes the logger ~ acts as the last resort garbage collector.
     *
     * This method is called last at __destruct() time.
     */
    public function close()
    {
        // empty
    }

    /**
     * Sets a log formatter.
     *
     * @param LogFormatter $formatter
     */
    public function setLogFormatter(LogFormatter $formatter)
    {
        $this->log_formatter = $formatter;
    }

    /**
     * Returns the current log formatter.
     *
     * @return LogFormatter
     */
    public function getLogFormatter()
    {    
        if(!$this->log_formatter) {
            $this->setLogFormatter(new LogFormatter);
        }

        return $this->log_formatter;
    }

    /**
     * Sets and merges the options for this logger, overriding any default.
     *
     * @param array|null $options
     */
    public function setOptions(array $options=null)
    {
        if (null !== $options) {
            $this->options = $options+$this->options;
        }
    }

}