Phalcon\Logger\Adapter\Stream

Complexity

Total Complexity

11

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Test Coverage

Coverage

67.92%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getName()	0	3	1
A	__construct()	0	9	2
A	close()	0	11	2
A	fopen()	0	3	1
A	fwrite()	0	3	1
A	fclose()	0	3	1
A	process()	0	24	3

<?php

/**
 * This file is part of the Phalcon Framework.
 *
 * (c) Phalcon Team <team@phalcon.io>
 *
 * For the full copyright and license information, please view the LICENSE.txt
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Phalcon\Logger\Adapter;

use LogicException;
use Phalcon\Helper\Arr;
use Phalcon\Logger\Exception;
use Phalcon\Logger\Item;

use function fclose;
use function fopen;
use function fwrite;
use function is_resource;
use function sprintf;
use function strpos;

use const PHP_EOL;

/**
 * Phalcon\Logger\Adapter\Stream
 *
 * Adapter to store logs in plain text files
 *
 *```php
 * $logger = new \Phalcon\Logger\Adapter\Stream("app/logs/test.log");
 *
 * $logger->log("This is a message");
 * $logger->log(\Phalcon\Logger::ERROR, "This is an error");
 * $logger->error("This is another error");
 *
 * $logger->close();
 *```
 *
 * @property resource|null $handler
 * @property string        $mode
 * @property string        $name
 * @property array         $options
 */
class Stream extends AbstractAdapter
{
    /**
     * Stream handler resource
     *
     * @var resource|null
     */
    protected $handler = null;

    /**
     * The file open mode. Defaults to "ab"
     *
     * @var string
     */
    protected $mode = "ab";

    /**
     * Stream name
     *
     * @var string
     */
    protected $name;

    /**
     * Path options
     *
     * @var array
     */
    protected $options;

    /**
     * Stream constructor.
     *
     * @param string $name
     * @param array  $options
     *
     * @throws Exception
     */
    public function __construct(string $name, array $options = [])
    {
        $mode = Arr::get($options, "mode", "ab");
        if (false !== strpos($mode, "r")) {
            throw new Exception("Adapter cannot be opened in read mode");
        }

        $this->name = $name;
        $this->mode = $mode;
    }

    /**
     * Closes the stream
     */
    public function close(): bool
    {
        $result = true;

        if (is_resource($this->handler)) {
            $result = $this->fclose($this->handler);
        }

        $this->handler = null;

        return $result;
    }

    /**
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * Processes the message i.e. writes it to the file
     *
     * @param Item $item
     */
    public function process(Item $item): void
    {
        if (!is_resource($this->handler)) {
            $handler = $this->fopen($this->name, $this->mode);

            if (!is_resource($handler)) {
                $this->handler = null;

                throw new LogicException(
                    sprintf(
                        "The file '%s' cannot be opened with mode '%s'",
                        $this->name,
                        $this->mode
                    )
                );
            }

            $this->handler = $handler;
        }

        $formatter        = $this->getFormatter();
        $formattedMessage = (string) $formatter->format($item) . PHP_EOL;

        $this->fwrite($this->handler, $formattedMessage);
    }

    /**
     * Closes an open file pointer
     *
     * @link https://php.net/manual/en/function.fclose.php
     *
     * @param resource $handle
     *
     * @return bool
     */
    public function fclose($handle)
    {
        return fclose($handle);
    }

    /**
     * Opens file or URL
     *
     * @link https://php.net/manual/en/function.fopen.php
     *
     * @param string        $filename
     * @param string        $mode
     *
     * @return false|resource
     */
    protected function fopen($filename, $mode)
    {
        return fopen($filename, $mode);
    }

    /**
     * Binary-safe file write
     *
     * @link https://php.net/manual/en/function.fwrite.php
     *
     * @param resource $handle
     * @param string   $string
     *
     * @return int|false
     */
    protected function fwrite($handle, $string)
    {
        return fwrite($handle, $string);
    }
}