Log::alert() - Code Metrics - Inspection of "LoggerFactory" - itrukhin/bxmonolog - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1e4b3a...3c3497 )

by Ioannes

created 2021-11-13 19:54 UTC

Log::alert() A

↳ Parent: Log

Complexity

Conditions	2
Paths	4

Size

Total Lines	8
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	6
c	1
b	0
f	0
dl	0
loc	8
rs	10
cc	2
nc	4
nop	2

<?php
namespace App;

use App\Monolog\LoggerFactory;
use Bitrix\Main\Diag\Debug;
filter:
    dependency_paths: ["lib/*"]
use Bitrix\Main\Error;
filter:
    dependency_paths: ["lib/*"]
use Monolog\Logger;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;

class Log implements LoggerInterface {

    private $channel;

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

        if(!empty($channel)) {
            $this->channel = $channel;
        } else {
            $this->channel = ($_ENV['APP_LOG_BITRIX_CHANNEL'] ?: 'bitrix');
        }
    }

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

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

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

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

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

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

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

    /**
     * @param mixed $message
     * @param array $context
     */
    public function emergency($message, $context = [])
    {
        try {
            $logger = LoggerFactory::getInstance($this->channel, $context);
            $message = $this->formatMessage($message);
            $logger->emergency($message, (array) $context);
        } catch (\Exception $e) {
            $this->logInnerException($e);
        }
    }

    /**
     * @param mixed $level
     * @param mixed $message
     * @param array $context
     */
    public function log($level, $message, $context = [])
    {
        if ($this->isDebugEnabled($level)) {
            try {
                $logger = LoggerFactory::getInstance($this->channel, $context);
                $message = $this->formatMessage($message);
                $logger->log($level, $message, (array) $context);
            } catch (\Exception $e) {
                $this->logInnerException($e);
            }
        }
    }

    /**
     * @param mixed $level
     * @param mixed $message
     * @param array $context
     */
    public function telegram($level, $message, $context = []) {

        $level = Logger::toMonologLevel($level);
        if (!$this->isDebugEnabled($level)) {
            return;
        }

        $logger = LoggerFactory::getInstance('telegram-messenger', $context);

        if($logger) {
            $logger->log($level, $message, $context);
        }
    }

    /**
     * @param mixed $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;
    }

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

            return true;
        }

        $level = Logger::toMonologLevel($level);

        $levels = Logger::getLevels();

        $minDebugLevel = ($_ENV['APP_DEBUG_LEVEL'] ?: LogLevel::DEBUG);
        $minDebugLevel = Logger::toMonologLevel($minDebugLevel);

        if($level >= $minDebugLevel) {
            return true;
        }
        return false;
    }

    /**
     * @param \Exception $exception
     */
    protected 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);
    }
}


1			<?php
2			namespace App;
3
4			use App\Monolog\LoggerFactory;
5			use Bitrix\Main\Diag\Debug;
			0 ignored issues – show Bug introduced 2021-11-11 20:15 UTC by Report Bug Copy Issue Report The type `Bitrix\Main\Diag\Debug` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
6			use Bitrix\Main\Error;
			0 ignored issues – show Bug introduced 2021-11-11 20:15 UTC by Report Bug Copy Issue Report The type `Bitrix\Main\Error` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
7			use Monolog\Logger;
8			use Psr\Log\LoggerInterface;
9			use Psr\Log\LogLevel;
10
11			class Log implements LoggerInterface {
12
13			private $channel;
14
15			/**
16			* @param string $channel
17			*/
18			public function __construct($channel = '') {
19
20			if(!empty($channel)) {
21			$this->channel = $channel;
22			} else {
23			$this->channel = ($_ENV['APP_LOG_BITRIX_CHANNEL'] ?: 'bitrix');
24			}
25			}
26
27			/**
28			* @param mixed $message
29			* @param array $context
30			*/
31			public function alert($message, $context = [])
32			{
33			try {
34			$logger = LoggerFactory::getInstance($this->channel, $context);
35			$message = $this->formatMessage($message);
36			$logger->alert($message, (array) $context);
37			} catch (\Exception $e) {
38			$this->logInnerException($e);
39			}
40			}
41
42			/**
43			* @param mixed $message
44			* @param array $context
45			*/
46			public function critical($message, $context = [])
47			{
48			try {
49			$logger = LoggerFactory::getInstance($this->channel, $context);
50			$message = $this->formatMessage($message);
51			$logger->critical($message, (array) $context);
52			} catch (\Exception $e) {
53			$this->logInnerException($e);
54			}
55			}
56
57			/**
58			* @param mixed $message
59			* @param array $context
60			*/
61			public function error($message, $context = [])
62			{
63			if ($this->isDebugEnabled(Logger::ERROR)) {
64			try {
65			$logger = LoggerFactory::getInstance($this->channel, $context);
66			$message = $this->formatMessage($message);
67			$logger->error($message, (array) $context);
68			} catch (\Exception $e) {
69			$this->logInnerException($e);
70			}
71			}
72			}
73
74			/**
75			* @param mixed $message
76			* @param array $context
77			*/
78			public function warning($message, $context = [])
79			{
80			if ($this->isDebugEnabled(Logger::WARNING)) {
81			try {
82			$logger = LoggerFactory::getInstance($this->channel, $context);
83			$message = $this->formatMessage($message);
84			$logger->warning($message, (array) $context);
85			} catch (\Exception $e) {
86			$this->logInnerException($e);
87			}
88			}
89			}
90
91			/**
92			* @param mixed $message
93			* @param array $context
94			*/
95			public function notice($message, $context = [])
96			{
97			if ($this->isDebugEnabled(Logger::NOTICE)) {
98			try {
99			$logger = LoggerFactory::getInstance($this->channel, $context);
100			$message = $this->formatMessage($message);
101			$logger->notice($message, (array) $context);
102			} catch (\Exception $e) {
103			$this->logInnerException($e);
104			}
105			}
106			}
107
108			/**
109			* @param mixed $message
110			* @param array $context
111			*/
112			public function info($message, $context = [])
113			{
114			if ($this->isDebugEnabled(Logger::INFO)) {
115			try {
116			$logger = LoggerFactory::getInstance($this->channel, $context);
117			$message = $this->formatMessage($message);
118			$logger->info($message, (array) $context);
119			} catch (\Exception $e) {
120			$this->logInnerException($e);
121			}
122			}
123			}
124
125			/**
126			* @param mixed $message
127			* @param array $context
128			*/
129			public function debug($message, $context = [])
130			{
131			if ($this->isDebugEnabled(Logger::DEBUG)) {
132			try {
133			$logger = LoggerFactory::getInstance($this->channel, $context);
134			$message = $this->formatMessage($message);
135			$logger->debug($message, (array) $context);
136			} catch (\Exception $e) {
137			$this->logInnerException($e);
138			}
139			}
140			}
141
142			/**
143			* @param mixed $message
144			* @param array $context
145			*/
146			public function emergency($message, $context = [])
147			{
148			try {
149			$logger = LoggerFactory::getInstance($this->channel, $context);
150			$message = $this->formatMessage($message);
151			$logger->emergency($message, (array) $context);
152			} catch (\Exception $e) {
153			$this->logInnerException($e);
154			}
155			}
156
157			/**
158			* @param mixed $level
159			* @param mixed $message
160			* @param array $context
161			*/
162			public function log($level, $message, $context = [])
163			{
164			if ($this->isDebugEnabled($level)) {
165			try {
166			$logger = LoggerFactory::getInstance($this->channel, $context);
167			$message = $this->formatMessage($message);
168			$logger->log($level, $message, (array) $context);
169			} catch (\Exception $e) {
170			$this->logInnerException($e);
171			}
172			}
173			}
174
175			/**
176			* @param mixed $level
177			* @param mixed $message
178			* @param array $context
179			*/
180			public function telegram($level, $message, $context = []) {
181
182			$level = Logger::toMonologLevel($level);
183			if (!$this->isDebugEnabled($level)) {
184			return;
185			}
186
187			$logger = LoggerFactory::getInstance('telegram-messenger', $context);
188
189			if($logger) {
190			$logger->log($level, $message, $context);
191			}
192			}
193
194			/**
195			* @param mixed $message
196			* @return string
197			*/
198			private function formatMessage($message) {
199
200			if($message instanceof \Exception \|\| $message instanceof Error) {
201			$message = (string) $message;
202			} else if(is_array($message) \|\| is_object($message)) {
203			$message = json_encode((array) $message, JSON_PRETTY_PRINT \| JSON_UNESCAPED_UNICODE \| JSON_UNESCAPED_SLASHES);
204			$message = str_replace('\\u0000', '', $message);
205			}
206			return (string) $message;
207			}
208
209			/**
210			* @param mixed $level
211			* @return bool
212			*/
213			private function isDebugEnabled($level)
214			{
215			if (defined('FORCE_DEBUG') && FORCE_DEBUG) {
			0 ignored issues – show Bug introduced 2021-11-11 20:15 UTC by Report Bug Copy Issue Report The constant `App\FORCE_DEBUG` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
216			return true;
217			}
218
219			$level = Logger::toMonologLevel($level);
220
221			$levels = Logger::getLevels();
			0 ignored issues – show Unused Code introduced 2021-11-13 19:56 UTC by Report Bug Copy Issue Report The assignment to `$levels` is dead and can be removed. Loading history...
222			$minDebugLevel = ($_ENV['APP_DEBUG_LEVEL'] ?: LogLevel::DEBUG);
223			$minDebugLevel = Logger::toMonologLevel($minDebugLevel);
224
225			if($level >= $minDebugLevel) {
226			return true;
227			}
228			return false;
229			}
230
231			/**
232			* @param \Exception $exception
233			*/
234			protected function logInnerException(\Exception $exception)
235			{
236			Debug::writeToFile((string) $exception, "", "inner_error.log");
237			}
238
239			public static function cleanLogs($daysAgo = 15) {
240
241			$logPath = $_SERVER['DOCUMENT_ROOT'] . ($_ENV['APP_LOG_FOLDER'] ?: '/log/');
242			$command = sprintf("find %s -mindepth 1 -type f -mtime +%d \| xargs rm", $logPath, $daysAgo);
243			exec($command);
244			return sprintf('\App\Log::cleanLogs(%d);', $daysAgo);
245			}
246			}
247

itrukhin / bxmonolog

Push — master ( 1e4b3a...3c3497 )

Log::alert() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like