Weew\App\Monolog\Loggers\PrefixedLogger

Complexity

Total Complexity

17

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__call()	0	3	1
A	getLogger()	0	3	1
A	getPrefix()	0	3	1
A	emergency()	0	3	1
A	alert()	0	3	1
A	critical()	0	3	1
A	error()	0	3	1
A	warning()	0	3	1
A	notice()	0	3	1
A	info()	0	3	1
A	debug()	0	3	1
A	log()	0	3	1
A	prefixMessage()	0	7	2
A	determinePrefix()	0	9	2

<?php

namespace Weew\App\Monolog\Loggers;

use Psr\Log\LoggerInterface;
use ReflectionClass;

class PrefixedLogger implements LoggerInterface {
    /**
     * @var Logger
     */
    private $logger;

    /**
     * @var string
     */
    private $prefix;

    /**
     * PrefixedLogger constructor.
     *
     * @param LoggerInterface $logger
     * @param prefix $prefix
     */
    public function __construct(LoggerInterface $logger, $prefix = null) {
        $this->logger = $logger;

$logger is of type object<Psr\Log\LoggerInterface>, but the property $logger was declared to be of type object<Weew\App\Monolog\Loggers\Logger>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->prefix = $this->determinePrefix($prefix);

It seems like $prefix defined by parameter $prefix on line 25 can be null; however, Weew\App\Monolog\Loggers\PrefixedLogger::determinePrefix() does not accept null, maybe add an additional type check?

    }

    /**
     * @param string $method
     * @param array $args
     *
     * @return mixed
     */
    public function __call($method, array $args) {
        return call_user_func_array([$this->logger, $method], $args);
    }

    /**
     * @return Logger
     */
    public function getLogger() {
        return $this->logger;
    }

    /**
     * @return string
     */
    public function getPrefix() {
        return $this->prefix;
    }

    /**
     * System is unusable.
     *
     * @param string $message
     * @param array $context
     *
     * @return null
     */
    public function emergency($message, array $context = []) {
        $this->logger->emergency($this->prefixMessage($message), $context);
    }

    /**
     * Action must be taken immediately.
     *
     * Example: Entire website down, database unavailable, etc. This should
     * trigger the SMS alerts and wake you up.
     *
     * @param string $message
     * @param array $context
     *
     * @return null
     */
    public function alert($message, array $context = []) {
        $this->logger->alert($this->prefixMessage($message), $context);
    }

    /**
     * Critical conditions.
     *
     * Example: Application component unavailable, unexpected exception.
     *
     * @param string $message
     * @param array $context
     *
     * @return null
     */
    public function critical($message, array $context = []) {
        $this->logger->critical($this->prefixMessage($message), $context);
    }

    /**
     * Runtime errors that do not require immediate action but should typically
     * be logged and monitored.
     *
     * @param string $message
     * @param array $context
     *
     * @return null
     */
    public function error($message, array $context = []) {
        $this->logger->error($this->prefixMessage($message), $context);
    }

    /**
     * Exceptional occurrences that are not errors.
     *
     * Example: Use of deprecated APIs, poor use of an API, undesirable things
     * that are not necessarily wrong.
     *
     * @param string $message
     * @param array $context
     *
     * @return null
     */
    public function warning($message, array $context = []) {
        $this->logger->warning($this->prefixMessage($message), $context);
    }

    /**
     * Normal but significant events.
     *
     * @param string $message
     * @param array $context
     *
     * @return null
     */
    public function notice($message, array $context = []) {
        $this->logger->notice($this->prefixMessage($message), $context);
    }

    /**
     * Interesting events.
     *
     * Example: User logs in, SQL logs.
     *
     * @param string $message
     * @param array $context
     *
     * @return null
     */
    public function info($message, array $context = []) {
        $this->logger->info($this->prefixMessage($message), $context);
    }

    /**
     * Detailed debug information.
     *
     * @param string $message
     * @param array $context
     *
     * @return null
     */
    public function debug($message, array $context = []) {
        $this->logger->debug($this->prefixMessage($message), $context);
    }

    /**
     * Logs with an arbitrary level.
     *
     * @param mixed $level
     * @param string $message
     * @param array $context
     *
     * @return null
     */
    public function log($level, $message, array $context = []) {
        $this->logger->log($level, $this->prefixMessage($message), $context);
    }

    /**
     * @param string $message
     *
     * @return string
     */
    protected function prefixMessage($message) {
        if ($this->prefix !== null) {
            return s('%s: %s', $this->prefix, $message);
        }

        return $message;
    }

    /**
     * @param string|object $prefix
     *
     * @return string
     */
    protected function determinePrefix($prefix) {
        if (is_object($prefix)) {
            $reflector = new ReflectionClass($prefix);

            return $reflector->getShortName();
        }

        return $prefix;
    }
}