Target::getFormattedMessages() - Code Metrics - Inspection of "Add StreamTarget for writes to output stream (#55)" - yiisoft/log - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d18874...8189de )

by Evgeniy

created 2020-12-01 16:07 UTC

Target::getFormattedMessages() A

↳ Parent: Target

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	4
nc	2
nop	0
dl	0
loc	9
ccs	5
cts	5
cp	1
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Yiisoft\Log;

use InvalidArgumentException;
use RuntimeException;
use Yiisoft\Arrays\ArrayHelper;

use function gettype;
use function in_array;
use function is_array;
use function is_bool;
use function is_string;
use function sprintf;

/**
 * Target is the base class for all log target classes.
 *
 * A log target object will filter the messages logged by {@see \Yiisoft\Log\Logger} according
 * to its {@see Target::setLevels()} and {@see Target::setCategories()}. It may also export
 * the filtered messages to specific destination defined by the target, such as emails, files.
 *
 * Level filter and category filter are combinatorial, i.e., only messages
 * satisfying both filter conditions will be handled. Additionally, you may
 * specify {@see Target::setExcept()} to exclude messages of certain categories.
 */
abstract class Target
{
    private MessageCategoryFilter $categories;
    private MessageCollection $messages;
    private MessageFormatter $formatter;

    /**
     * @var string[] List of the PHP predefined variables that should be logged in a message.
     *
     * This data will be available in the context of the log message using the "globals" key.
     *
     * Note that a variable must be accessible via `$GLOBALS`. Otherwise it won't be logged.
     * Defaults to `['_GET', '_POST', '_FILES', '_COOKIE', '_SESSION', '_SERVER']`.
     *
     * Each element can also be specified as one of the following:
     *
     * - `var` - `var` will be logged.
     * - `var.key` - only `var[key]` key will be logged.
     * - `!var.key` - `var[key]` key will be excluded.
     *
     * Note that if you need $_SESSION to logged regardless if session
     * was used you have to open it right at he start of your request.
     *
     * @see \Yiisoft\Arrays\ArrayHelper::filter()
     * @see MessageCollection::$messages
     */
    private array $logGlobals = ['_GET', '_POST', '_FILES', '_COOKIE', '_SESSION', '_SERVER'];

    /**
     * @var array The list of user parameters in the `key => value` format.
     *
     * This data will be available in the context of the log message using the "params" key.
     *
     * @see MessageCollection::$messages
     */
    private array $logParams = [];

    /**
     * @var int How many log messages should be accumulated before they are exported.
     *
     * Defaults to 1000. Note that messages will always be exported when the application terminates.
     * Set this property to be 0 if you don't want to export messages until the application terminates.
     */
    private int $exportInterval = 1000;

    /**
     * @var bool|callable Enables or disables the current target to export.
     */
    private $enabled = true;

    /**
     * Exports log messages to a specific destination.
     * Child classes must implement this method.
     */
    abstract protected function export(): void;

    /**
     * When defining a constructor in child classes, you must call `parent::__construct()`.
     */
    public function __construct()
    {
        $this->categories = new MessageCategoryFilter();
        $this->messages = new MessageCollection();
        $this->formatter = new MessageFormatter();
    }

    /**
     * Processes the given log messages.
     *
     * This method will filter the given messages with levels and categories.
     * The message structure follows that in {@see MessageCollection::$messages}.
     * And if requested, it will also export the filtering result to specific medium (e.g. email).
     *
     * @param array $messages Log messages to be processed.
     * @param bool $final Whether this method is called at the end of the current application.
     */
    public function collect(array $messages, bool $final): void
    {
        $this->messages->addMultiple($this->filterMessages($messages));
        $count = $this->messages->count();

        if ($count > 0 && ($final || ($this->exportInterval > 0 && $count >= $this->exportInterval))) {
            // set exportInterval to 0 to avoid triggering export again while exporting
            $oldExportInterval = $this->exportInterval;
            $this->exportInterval = 0;
            $this->export();
            $this->exportInterval = $oldExportInterval;
            $this->messages->clear();
        }
    }

    /**
     * Sets a list of log message categories that this target is interested in.
     *
     * @param array $categories The list of log message categories.
     *
     * @throws InvalidArgumentException for invalid log message categories structure.
     *
     * @return self
     *
     * @see MessageCategoryFilter::$include
     */
    public function setCategories(array $categories): self
    {
        $this->categories->include($categories);
        return $this;
    }

    /**
     * Sets a list of log message categories that this target is NOT interested in.
     *
     * @param array $except The list of log message categories.
     *
     * @throws InvalidArgumentException for invalid log message categories structure.
     *
     * @return self
     *
     * @see MessageCategoryFilter::$exclude
     */
    public function setExcept(array $except): self
    {
        $this->categories->exclude($except);
        return $this;
    }

    /**
     * Sets a list of log message levels that current target is interested in.
     *
     * @param array $levels The list of log message levels.
     *
     * @throws InvalidArgumentException for invalid log message level.
     *
     * @return self
     *
     * @see MessageCollection::$levels
     */
    public function setLevels(array $levels): self
    {
        $this->messages->setLevels($levels);
        return $this;
    }

    /**
     * Sets a list of the predefined PHP global variables that should be logged in a message.
     *
     * @param array $logGlobals The list of PHP global variables.
     *
     * @throws InvalidArgumentException for non-string values.
     *
     * @return self
     *
     * @see Target::$logGlobals
     */
    public function setLogGlobals(array $logGlobals): self
    {
        $this->checkGlobalNames($logGlobals);
        $this->logGlobals = $logGlobals;
        return $this;
    }

    /**
     * Sets a list of user parameters in the `key => value` format.
     *
     * @param array $logParams The list of user parameters.
     *
     * @return self
     *
     * @see Target::$logParams
     */
    public function setLogParams(array $logParams): self
    {
        $this->logParams = $logParams;
        return $this;
    }

    /**
     * Sets a PHP callable that returns a string representation of the log message.
     *
     * @param callable $format The PHP callable to get a string value from.
     *
     * @return self
     *
     * @see MessageFormatter::$format
     */
    public function setFormat(callable $format): self
    {
        $this->formatter->setFormat($format);
        return $this;
    }

    /**
     * Sets a PHP callable that returns a string to be prefixed to every exported message.
     *
     * @param callable $prefix The PHP callable to get a string prefix of the log message.
     *
     * @return self
     *
     * @see MessageFormatter::$prefix
     */
    public function setPrefix(callable $prefix): self
    {
        $this->formatter->setPrefix($prefix);
        return $this;
    }

    /**
     * Sets how many messages should be accumulated before they are exported.
     *
     * @param int $exportInterval The number of log messages to accumulate before exporting.
     *
     * @return self
     *
     * @see Target::$exportInterval
     */
    public function setExportInterval(int $exportInterval): self
    {
        $this->exportInterval = $exportInterval;
        return $this;
    }

    /**
     * Sets a date format for the log timestamp.
     *
     * @param string $format The date format for the log timestamp.
     *
     * @return self
     *
     * @see Target::$timestampFormat
     */
    public function setTimestampFormat(string $format): self
    {
        $this->formatter->setTimestampFormat($format);
        return $this;
    }

    /**
     * Sets a PHP callable that returns a boolean indicating whether this log target is enabled.
     *
     * @param callable $value The PHP callable to get a boolean value.
     *
     * @return self
     *
     * @see Target::$enabled
     */
    public function setEnabled(callable $value): self
    {
        $this->enabled = $value;
        return $this;
    }

    /**
     * Enables the log target.
     *
     * @return self
     *
     * @see Target::$enabled
     */
    public function enable(): self
    {
        $this->enabled = true;
        return $this;
    }

    /**
     * Disables the log target.
     *
     * @return self
     *
     * @see Target::$enabled
     */
    public function disable(): self
    {
        $this->enabled = false;
        return $this;
    }

    /**
     * Check whether the log target is enabled.
     *
     * @throws RuntimeException for a callable "enabled" that does not return a boolean.
     *
     * @return bool The value indicating whether this log target is enabled.
     *
     * @see Target::$enabled
     */
    public function isEnabled(): bool
    {
        if (is_bool($this->enabled)) {
            return $this->enabled;
        }

        if (!is_bool($enabled = ($this->enabled)($this))) {
            throw new RuntimeException(sprintf(
                'The PHP callable "enabled" must returns a boolean, %s received.',
                gettype($enabled)
            ));
        }

        return $enabled;
    }

    /**
     * Gets a list of log messages that are retrieved from the logger so far by this log target.
     *
     * @return array[] The list of log messages.
     *
     * @see MessageCollection::$messages
     */
    protected function getMessages(): array
    {
        return $this->messages->all();
    }

    /**
     * Gets a list of formatted log messages.
     *
     * @return array The list of formatted log messages.
     */
    protected function getFormattedMessages(): array
    {
        $formatted = [];

        foreach ($this->messages->all() as $key => $message) {
            $formatted[$key] = $this->formatter->format($message);
        }

        return $formatted;
    }

    /**
     * Formats all log messages for display as a string.
     *
     * @param string $separator The log messages string separator.
     *
     * @return string The string formatted log messages.
     */
    protected function formatMessages(string $separator = ''): string
    {
        $formatted = '';

        foreach ($this->messages->all() as $message) {
            $formatted .= $this->formatter->format($message) . $separator;
        }

        return $formatted;
    }

    /**
     * Filters the given messages according to their categories and levels.
     *
     * The message structure follows that in {@see MessageCollection::$messages}.
     *
     * @param array[] $messages List log messages to be filtered.
     *
     * @return array[] The filtered log messages.
     */
    private function filterMessages(array $messages): array
    {
        foreach ($messages as $i => $message) {
            $levels = $this->messages->getLevels();

            if ((!empty($levels) && !in_array(($message[0] ?? ''), $levels, true))) {
                unset($messages[$i]);
                continue;
            }

            if ($this->categories->isExcluded((string) ($message[2]['category'] ?? ''))) {
                unset($messages[$i]);
                continue;
            }

            if (!isset($message[2]['params']) || !is_array($message[2]['params'])) {
                $message[2]['params'] = $this->logParams;
            }

            if (isset($message[2]['globals']) && is_array($message[2]['globals'])) {
                $this->checkGlobalNames($message[2]['globals']);
                $globals = $message[2]['globals'];
            }

            $message[2]['globals'] = ArrayHelper::filter($GLOBALS, $globals ?? $this->logGlobals);
            $messages[$i] = $message;
        }

        return $messages;
    }

    /**
     * Checks PHP global variable names.
     *
     * @param array $logGlobals The list of PHP global variable names to be checked.
     *
     * @throws InvalidArgumentException for non-string values or empty string.
     *
     * @see Target::$logGlobals
     */
    private function checkGlobalNames(array $logGlobals): void
    {
        foreach ($logGlobals as $logGlobal) {
            if (!is_string($logGlobal) || $logGlobal === '') {
                throw new InvalidArgumentException(sprintf(
                    'The PHP global variable name must be a not empty string, %s received.',
                    gettype($logGlobal)
                ));
            }
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Log;
6
7		use InvalidArgumentException;
8		use RuntimeException;
9		use Yiisoft\Arrays\ArrayHelper;
10
11		use function gettype;
12		use function in_array;
13		use function is_array;
14		use function is_bool;
15		use function is_string;
16		use function sprintf;
17
18		/**
19		* Target is the base class for all log target classes.
20		*
21		* A log target object will filter the messages logged by {@see \Yiisoft\Log\Logger} according
22		* to its {@see Target::setLevels()} and {@see Target::setCategories()}. It may also export
23		* the filtered messages to specific destination defined by the target, such as emails, files.
24		*
25		* Level filter and category filter are combinatorial, i.e., only messages
26		* satisfying both filter conditions will be handled. Additionally, you may
27		* specify {@see Target::setExcept()} to exclude messages of certain categories.
28		*/
29		abstract class Target
30		{
31		private MessageCategoryFilter $categories;
32		private MessageCollection $messages;
33		private MessageFormatter $formatter;
34
35		/**
36		* @var string[] List of the PHP predefined variables that should be logged in a message.
37		*
38		* This data will be available in the context of the log message using the "globals" key.
39		*
40		* Note that a variable must be accessible via `$GLOBALS`. Otherwise it won't be logged.
41		* Defaults to `['_GET', '_POST', '_FILES', '_COOKIE', '_SESSION', '_SERVER']`.
42		*
43		* Each element can also be specified as one of the following:
44		*
45		* - `var` - `var` will be logged.
46		* - `var.key` - only `var[key]` key will be logged.
47		* - `!var.key` - `var[key]` key will be excluded.
48		*
49		* Note that if you need $_SESSION to logged regardless if session
50		* was used you have to open it right at he start of your request.
51		*
52		* @see \Yiisoft\Arrays\ArrayHelper::filter()
53		* @see MessageCollection::$messages
54		*/
55		private array $logGlobals = ['_GET', '_POST', '_FILES', '_COOKIE', '_SESSION', '_SERVER'];
56
57		/**
58		* @var array The list of user parameters in the `key => value` format.
59		*
60		* This data will be available in the context of the log message using the "params" key.
61		*
62		* @see MessageCollection::$messages
63		*/
64		private array $logParams = [];
65
66		/**
67		* @var int How many log messages should be accumulated before they are exported.
68		*
69		* Defaults to 1000. Note that messages will always be exported when the application terminates.
70		* Set this property to be 0 if you don't want to export messages until the application terminates.
71		*/
72		private int $exportInterval = 1000;
73
74		/**
75		* @var bool\|callable Enables or disables the current target to export.
76		*/
77		private $enabled = true;
78
79		/**
80		* Exports log messages to a specific destination.
81		* Child classes must implement this method.
82		*/
83		abstract protected function export(): void;
84
85		/**
86		* When defining a constructor in child classes, you must call `parent::__construct()`.
87		*/
88	140	public function __construct()
89		{
90	140	$this->categories = new MessageCategoryFilter();
91	140	$this->messages = new MessageCollection();
92	140	$this->formatter = new MessageFormatter();
93	140	}
94
95		/**
96		* Processes the given log messages.
97		*
98		* This method will filter the given messages with levels and categories.
99		* The message structure follows that in {@see MessageCollection::$messages}.
100		* And if requested, it will also export the filtering result to specific medium (e.g. email).
101		*
102		* @param array $messages Log messages to be processed.
103		* @param bool $final Whether this method is called at the end of the current application.
104		*/
105	72	public function collect(array $messages, bool $final): void
106		{
107	72	$this->messages->addMultiple($this->filterMessages($messages));
108	68	$count = $this->messages->count();
109
110	68	if ($count > 0 && ($final \|\| ($this->exportInterval > 0 && $count >= $this->exportInterval))) {
111		// set exportInterval to 0 to avoid triggering export again while exporting
112	31	$oldExportInterval = $this->exportInterval;
113	31	$this->exportInterval = 0;
114	31	$this->export();
115	25	$this->exportInterval = $oldExportInterval;
116	25	$this->messages->clear();
117		}
118	62	}
119
120		/**
121		* Sets a list of log message categories that this target is interested in.
122		*
123		* @param array $categories The list of log message categories.
124		*
125		* @throws InvalidArgumentException for invalid log message categories structure.
126		*
127		* @return self
128		*
129		* @see MessageCategoryFilter::$include
130		*/
131	18	public function setCategories(array $categories): self
132		{
133	18	$this->categories->include($categories);
134	12	return $this;
135		}
136
137		/**
138		* Sets a list of log message categories that this target is NOT interested in.
139		*
140		* @param array $except The list of log message categories.
141		*
142		* @throws InvalidArgumentException for invalid log message categories structure.
143		*
144		* @return self
145		*
146		* @see MessageCategoryFilter::$exclude
147		*/
148	9	public function setExcept(array $except): self
149		{
150	9	$this->categories->exclude($except);
151	3	return $this;
152		}
153
154		/**
155		* Sets a list of log message levels that current target is interested in.
156		*
157		* @param array $levels The list of log message levels.
158		*
159		* @throws InvalidArgumentException for invalid log message level.
160		*
161		* @return self
162		*
163		* @see MessageCollection::$levels
164		*/
165	15	public function setLevels(array $levels): self
166		{
167	15	$this->messages->setLevels($levels);
168	9	return $this;
169		}
170
171		/**
172		* Sets a list of the predefined PHP global variables that should be logged in a message.
173		*
174		* @param array $logGlobals The list of PHP global variables.
175		*
176		* @throws InvalidArgumentException for non-string values.
177		*
178		* @return self
179		*
180		* @see Target::$logGlobals
181		*/
182	131	public function setLogGlobals(array $logGlobals): self
183		{
184	131	$this->checkGlobalNames($logGlobals);
185	131	$this->logGlobals = $logGlobals;
186	131	return $this;
187		}
188
189		/**
190		* Sets a list of user parameters in the `key => value` format.
191		*
192		* @param array $logParams The list of user parameters.
193		*
194		* @return self
195		*
196		* @see Target::$logParams
197		*/
198	23	public function setLogParams(array $logParams): self
199		{
200	23	$this->logParams = $logParams;
201	23	return $this;
202		}
203
204		/**
205		* Sets a PHP callable that returns a string representation of the log message.
206		*
207		* @param callable $format The PHP callable to get a string value from.
208		*
209		* @return self
210		*
211		* @see MessageFormatter::$format
212		*/
213	24	public function setFormat(callable $format): self
214		{
215	24	$this->formatter->setFormat($format);
216	24	return $this;
217		}
218
219		/**
220		* Sets a PHP callable that returns a string to be prefixed to every exported message.
221		*
222		* @param callable $prefix The PHP callable to get a string prefix of the log message.
223		*
224		* @return self
225		*
226		* @see MessageFormatter::$prefix
227		*/
228	12	public function setPrefix(callable $prefix): self
229		{
230	12	$this->formatter->setPrefix($prefix);
231	12	return $this;
232		}
233
234		/**
235		* Sets how many messages should be accumulated before they are exported.
236		*
237		* @param int $exportInterval The number of log messages to accumulate before exporting.
238		*
239		* @return self
240		*
241		* @see Target::$exportInterval
242		*/
243	3	public function setExportInterval(int $exportInterval): self
244		{
245	3	$this->exportInterval = $exportInterval;
246	3	return $this;
247		}
248
249		/**
250		* Sets a date format for the log timestamp.
251		*
252		* @param string $format The date format for the log timestamp.
253		*
254		* @return self
255		*
256		* @see Target::$timestampFormat
257		*/
258	3	public function setTimestampFormat(string $format): self
259		{
260	3	$this->formatter->setTimestampFormat($format);
261	3	return $this;
262		}
263
264		/**
265		* Sets a PHP callable that returns a boolean indicating whether this log target is enabled.
266		*
267		* @param callable $value The PHP callable to get a boolean value.
268		*
269		* @return self
270		*
271		* @see Target::$enabled
272		*/
273	7	public function setEnabled(callable $value): self
274		{
275	7	$this->enabled = $value;
276	7	return $this;
277		}
278
279		/**
280		* Enables the log target.
281		*
282		* @return self
283		*
284		* @see Target::$enabled
285		*/
286	1	public function enable(): self
287		{
288	1	$this->enabled = true;
289	1	return $this;
290		}
291
292		/**
293		* Disables the log target.
294		*
295		* @return self
296		*
297		* @see Target::$enabled
298		*/
299	1	public function disable(): self
300		{
301	1	$this->enabled = false;
302	1	return $this;
303		}
304
305		/**
306		* Check whether the log target is enabled.
307		*
308		* @throws RuntimeException for a callable "enabled" that does not return a boolean.
309		*
310		* @return bool The value indicating whether this log target is enabled.
311		*
312		* @see Target::$enabled
313		*/
314	30	public function isEnabled(): bool
315		{
316	30	if (is_bool($this->enabled)) {
317	24	return $this->enabled;
318		}
319
320	7	if (!is_bool($enabled = ($this->enabled)($this))) {
321	6	throw new RuntimeException(sprintf(
322	6	'The PHP callable "enabled" must returns a boolean, %s received.',
323	6	gettype($enabled)
324		));
325		}
326
327	1	return $enabled;
328		}
329
330		/**
331		* Gets a list of log messages that are retrieved from the logger so far by this log target.
332		*
333		* @return array[] The list of log messages.
334		*
335		* @see MessageCollection::$messages
336		*/
337	42	protected function getMessages(): array
338		{
339	42	return $this->messages->all();
340		}
341
342		/**
343		* Gets a list of formatted log messages.
344		*
345		* @return array The list of formatted log messages.
346		*/
347	1	protected function getFormattedMessages(): array
348		{
349	1	$formatted = [];
350
351	1	foreach ($this->messages->all() as $key => $message) {
352	1	$formatted[$key] = $this->formatter->format($message);
353		}
354
355	1	return $formatted;
356		}
357
358		/**
359		* Formats all log messages for display as a string.
360		*
361		* @param string $separator The log messages string separator.
362		*
363		* @return string The string formatted log messages.
364		*/
365	21	protected function formatMessages(string $separator = ''): string
366		{
367	21	$formatted = '';
368
369	21	foreach ($this->messages->all() as $message) {
370	21	$formatted .= $this->formatter->format($message) . $separator;
371		}
372
373	9	return $formatted;
374		}
375
376		/**
377		* Filters the given messages according to their categories and levels.
378		*
379		* The message structure follows that in {@see MessageCollection::$messages}.
380		*
381		* @param array[] $messages List log messages to be filtered.
382		*
383		* @return array[] The filtered log messages.
384		*/
385	72	private function filterMessages(array $messages): array
386		{
387	72	foreach ($messages as $i => $message) {
388	72	$levels = $this->messages->getLevels();
389
390	72	if ((!empty($levels) && !in_array(($message[0] ?? ''), $levels, true))) {
391	7	unset($messages[$i]);
392	7	continue;
393		}
394
395	72	if ($this->categories->isExcluded((string) ($message[2]['category'] ?? ''))) {
396	13	unset($messages[$i]);
397	13	continue;
398		}
399
400	71	if (!isset($message[2]['params']) \|\| !is_array($message[2]['params'])) {
401	70	$message[2]['params'] = $this->logParams;
402		}
403
404	71	if (isset($message[2]['globals']) && is_array($message[2]['globals'])) {
405	1	$this->checkGlobalNames($message[2]['globals']);
406	1	$globals = $message[2]['globals'];
407		}
408
409	71	$message[2]['globals'] = ArrayHelper::filter($GLOBALS, $globals ?? $this->logGlobals);
410	71	$messages[$i] = $message;
411		}
412
413	72	return $messages;
414		}
415
416		/**
417		* Checks PHP global variable names.
418		*
419		* @param array $logGlobals The list of PHP global variable names to be checked.
420		*
421		* @throws InvalidArgumentException for non-string values or empty string.
422		*
423		* @see Target::$logGlobals
424		*/
425	131	private function checkGlobalNames(array $logGlobals): void
426		{
427	131	foreach ($logGlobals as $logGlobal) {
428	10	if (!is_string($logGlobal) \|\| $logGlobal === '') {
429	6	throw new InvalidArgumentException(sprintf(
430	6	'The PHP global variable name must be a not empty string, %s received.',
431	6	gettype($logGlobal)
432		));
433		}
434		}
435	131	}
436		}
437

yiisoft / log

Push — master ( d18874...8189de )

Target::getFormattedMessages() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like