App\Log

Complexity

Total Complexity

49

Size/Duplication

Total Lines	246
Duplicated Lines	0 %

Importance

Changes	7
Bugs	0	Features	1

16 Methods

Rating	Name	Duplication	Size	Complexity
A	formatMessage()	0	9	5
A	cleanLogs()	0	6	2
A	logInnerException()	0	3	1
A	error()	0	9	3
A	__construct()	0	8	4
A	alert()	0	8	2
A	notice()	0	9	3
A	critical()	0	8	2
A	isDebugEnabled()	0	10	4
A	warning()	0	9	3
A	log()	0	9	3
A	getLogger()	0	24	6
A	debug()	0	9	3
A	getMinErrorLevel()	0	8	3
A	info()	0	9	3
A	emergency()	0	8	2

<?php
namespace App;

use App\Monolog\ArrayFormatter;
use Bitrix\Main\Diag\Debug;

The type Bitrix\Main\Diag\Debug was not found. Maybe you did not declare it correctly or list all dependencies?

use Bitrix\Main\Error;

The type Bitrix\Main\Error was not found. Maybe you did not declare it correctly or list all dependencies?

use Monolog\Handler\StreamHandler;
use Monolog\Logger;
use Monolog\Registry;
use Psr\Log\LoggerInterface;

class Log implements LoggerInterface {

    private $channel;
    private $minDebugLevel;

    /**
     * @param false $channel
     */
    public function __construct($channel = false) {

        $this->minDebugLevel = ($_ENV['APP_DEBUG_LEVEL'] ?: 'DEBUG');
        if($channel) {

The condition $channel is always false.

            $this->channel = $channel;
            //TODO: get channel options
        } else {
            $this->channel = ($_ENV['APP_LOG_BITRIX_CHANNEL'] ?: 'bitrix');
        }
    }

    /**
     * @param $message
     * @param array $context
     */
    public function alert($message, $context = [])
    {
        try {
            $logger = $this->getLogger();
            $message = $this->formatMessage($message);
            $logger->alert($message, (array) $context);
        } catch (\Exception $e) {
            self::logInnerException($e);
        }
    }

    /**
     * @param $message
     * @param array $context
     */
    public function critical($message, $context = [])
    {
        try {
            $logger = $this->getLogger();
            $message = $this->formatMessage($message);
            $logger->critical($message, (array) $context);
        } catch (\Exception $e) {
            self::logInnerException($e);
        }
    }

    /**
     * @param $message
     * @param array $context
     */
    public function error($message, $context = [])
    {
        if ($this->isDebugEnabled(Logger::ERROR)) {
            try {
                $logger = $this->getLogger();
                $message = $this->formatMessage($message);
                $logger->error($message, (array) $context);
            } catch (\Exception $e) {
                self::logInnerException($e);
            }
        }
    }

    /**
     * @param $message
     * @param array $context
     */
    public function warning($message, $context = [])
    {
        if ($this->isDebugEnabled(Logger::WARNING)) {
            try {
                $logger = $this->getLogger();
                $message = $this->formatMessage($message);
                $logger->warning($message, (array) $context);
            } catch (\Exception $e) {
                self::logInnerException($e);
            }
        }
    }

    /**
     * @param $message
     * @param array $context
     */
    public function notice($message, $context = [])
    {
        if ($this->isDebugEnabled(Logger::NOTICE)) {
            try {
                $logger = $this->getLogger();
                $message = $this->formatMessage($message);
                $logger->notice($message, (array) $context);
            } catch (\Exception $e) {
                self::logInnerException($e);
            }
        }
    }

    /**
     * @param $message
     * @param array $context
     */
    public function info($message, $context = [])
    {
        if ($this->isDebugEnabled(Logger::INFO)) {
            try {
                $logger = $this->getLogger();
                $message = $this->formatMessage($message);
                $logger->info($message, (array) $context);
            } catch (\Exception $e) {
                self::logInnerException($e);
            }
        }
    }

    /**
     * @param $message
     * @param array $context
     */
    public function debug($message, $context = [])
    {
        if ($this->isDebugEnabled(Logger::DEBUG)) {
            try {
                $logger = $this->getLogger();
                $message = $this->formatMessage($message);
                $logger->debug($message, (array) $context);
            } catch (\Exception $e) {
                self::logInnerException($e);
            }
        }
    }

    public function emergency($message, $context = [])
    {
        try {
            $logger = $this->getLogger();
            $message = $this->formatMessage($message);
            $logger->emergency($message, (array) $context);
        } catch (\Exception $e) {
            self::logInnerException($e);
        }
    }

    public function log($level, $message, $context = [])
    {
        if ($this->isDebugEnabled($level)) {
            try {
                $logger = $this->getLogger();
                $message = $this->formatMessage($message);
                $logger->log($level, $message, (array) $context);
            } catch (\Exception $e) {
                self::logInnerException($e);
            }
        }
    }

    /**
     * @param $message
     * @return string
     */
    private function formatMessage($message) {

        if($message instanceof \Exception || $message instanceof Error) {
            $message = (string) $message;
        } else if(is_array($message) || is_object($message)) {
            $message = json_encode((array) $message, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
            $message = str_replace('\\u0000', '', $message);
        }
        return (string) $message;
    }

    /**
     * @return Logger
     */
    public function getLogger() {

        if(Registry::hasLogger($this->channel)) {
            return Registry::getInstance($this->channel);
        }
        $logPath = $_SERVER['DOCUMENT_ROOT'] . ($_ENV['APP_LOG_FOLDER'] ?: '/log/');
        $logPath .= $this->channel . '/' . date('Y-m-d') . '.log';
        $logDir = pathinfo($logPath, PATHINFO_DIRNAME);
        if(!file_exists($logDir)) {

It seems like $logDir can also be of type array; however, parameter $filename of file_exists() does only seem to accept string, maybe add an additional type check?

            $mode = 0775;
            if(defined('BX_DIR_PERMISSIONS') && BX_DIR_PERMISSIONS) {

The constant App\BX_DIR_PERMISSIONS was not found. Maybe you did not declare it correctly or list all dependencies?

                $mode = BX_DIR_PERMISSIONS;
            }
            mkdir($logDir, $mode, true);

It seems like $logDir can also be of type array; however, parameter $directory of mkdir() does only seem to accept string, maybe add an additional type check?

        }

        $handler = new StreamHandler($logPath);
        $handler->setFormatter(new ArrayFormatter());

        $logger = new Logger($this->channel);
        $logger->pushHandler($handler);
        Registry::addLogger($logger, $this->channel, true);

        return $logger;
    }

    /**
     * @return int|mixed
     */
    private function getMinErrorLevel() {

        $levels = Logger::getLevels();

        if($this->minDebugLevel && isset($levels[$this->minDebugLevel])) {
            return $levels[$this->minDebugLevel];
        } else {
            return Logger::DEBUG;
        }
    }

    /**
     * @param int $level
     * @return bool
     */
    private function isDebugEnabled($level = 0)
    {
        if (defined('FORCE_DEBUG') && FORCE_DEBUG) {

The constant App\FORCE_DEBUG was not found. Maybe you did not declare it correctly or list all dependencies?

            return true;
        }
        $min_level = $this->getMinErrorLevel();
        if($level >= $min_level) {
            return true;
        }
        return false;
    }

    /**
     * @param \Exception $exception
     */
    public static function logInnerException(\Exception $exception)
    {
        Debug::writeToFile((string) $exception, "", "inner_error.log");
    }

    public static function cleanLogs($daysAgo = 15) {

        $logPath = $_SERVER['DOCUMENT_ROOT'] . ($_ENV['APP_LOG_FOLDER'] ?: '/log/');
        $command = sprintf("find %s -mindepth 1 -type f -mtime +%d | xargs rm", $logPath, $daysAgo);
        exec($command);
        return sprintf('\App\Log::cleanLogs(%d);', $daysAgo);
    }
}