Syscodes\Log\Handlers\FileLogger

Complexity

Total Complexity

29

Size/Duplication

Total Lines	260
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	open()	0	7	3
A	__destruct()	0	4	2
A	getTimestamp()	0	8	1
B	handle()	0	34	7
A	log()	0	7	1
A	logMessage()	0	9	1
B	exchangeProcess()	0	30	11
A	cleanFileNames()	0	6	1

<?php

/**
 * Lenevor Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file license.md.
 * It is also available through the world-wide-web at this URL:
 * https://lenevor.com/license
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@Lenevor.com so we can send you a copy immediately.
 *
 * @package     Lenevor
 * @subpackage  Base
 * @link        https://lenevor.com
 * @copyright   Copyright (c) 2019 - 2021 Alexander Campo <jalexcam@gmail.com>
 * @license     https://opensource.org/licenses/BSD-3-Clause New BSD license or see https://lenevor.com/license or see /license.md
 */

namespace Syscodes\Log\Handlers;

use DateTime;
use Throwable;
use Syscodes\Support\Chronos;
use Syscodes\Contracts\Log\Handler;
use Syscodes\Log\Exceptions\LogException;
use Syscodes\Log\Concerns\ParseLogEnvironment;

/**
 * The Lenevor Logger of errors.
 * 
 * @author Alexander Campo <jalexcam@gmail.com>
 */
class FileLogger implements Handler
{
    use ParseLogEnvironment;
    
    /**
	 * The application implementation.
	 * 
	 * @var \Syscodes\Contracts\Core\Application $app
	 */
    protected $app;

    /**
     * Format of the timestamp for log files.
     * 
     * @var string $logDateFormat
     */
    protected $logDateFormat = 'Y-m-d H:i:s';

    /**
     * Extension to use for log files.
     * 
     * @var string $logExtension
     */
    protected $logFileExtension;

    /**
     * Path to the log file.
     * 
     * @var string $logFilePath
     */
    protected $logFilePath;

    /**
     * Octal notation for default permissions of the log file.
     * 
     * @var int $logFilePermissions
     */
    protected $logFilePermissions;

    /**
     * Caches instances of the handlers.
     * 
     * @var string $logHandler
     */
    protected $logHandler;

    /**
     * Write message in log file.
     * 
     * @var string $logMessage
     */
    protected $logMessage;

    /**
     * Constructor. The FileLogger class instance.
     * 
     * @param  array  $config
     * @param  \Syscodes\Contracts\Core\Application  $app
     * 
     * @return void
     */
    public function __construct(array $config = [], $app)
    {
        $this->app = $app;

        $this->logFilePath = $config['path'].DIRECTORY_SEPARATOR ?? STO_PATH.'logs'.DIRECTORY_SEPARATOR;

The constant Syscodes\Log\Handlers\STO_PATH was not found. Maybe you did not declare it correctly or list all dependencies?

        $this->logFileExtension = empty($config['extension']) ? 'log' : $config['extension'];
        $this->logFileExtension = ltrim($this->logFileExtension, '.');

        $this->logFilePermissions = $config['permission'] ?? 0644;
    }

    /**
     * Destructor. Close.
     * 
     * @return bool
     */
    public function __destruct()
    {
        if ($this->logHandler) {
            fclose($this->logHandler);

$this->logHandler of type string is incompatible with the type resource expected by parameter $stream of fclose().

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

        $this->handle($level, $message);

        return true;
    }

    /**
     * Replaces any placeholders in the message with variables
     * from the context.
     * 
     * @param  string  $message
     * @param  array  $context
     * 
     * @return mixed
     */
    protected function exchangeProcess($message, array $context = [])
    {
        if ( ! is_string($message)) {

The condition is_string($message) is always true.

            return $message;
        }
        
        $replace = [];
        
        foreach ($context as $key => $value) {
            if ($key === 'exception' && $value instanceof Throwable) {
                $value = $value->getMessage() . ' ' . $this->cleanFileNames($value->getFile()) . ':' . $value->getLine();
                // Todo - sanitize input before writing to file?
                $replace["{{$key}}"] = $value;
            } elseif (null === $value || is_scalar($value) || (is_object($value) && method_exists($value, '__toString'))) {
                $replace["{{$key}}"] = $value;
            } elseif ($value instanceof DateTime) {
                $replace["{{$key}}"] = $value->format(DateTime::RFC3339);
            } elseif (is_object($value)) {
                $replace["{{$key}}"] = '[object '.get_class($value).']';
            } else {
                $replace["{{$key}}"] = '['.gettype($value).']';
            }
        }
        
        // Add special placeholders
        $replace['{postVars}'] = '$_POST: '.print_r($_POST, true);

Are you sure print_r($_POST, true) of type string|true can be used in concatenation?

        $replace['{getVars}']  = '$_GET: '.print_r($_GET, true);

Are you sure print_r($_GET, true) of type string|true can be used in concatenation?

        $replace['{env}']      = '['.$this->getLogEnvironment().']';
        
        return strtr($message, $replace);
    }
    /**
     * Cleans the paths of filenames by replacing APPPATH, SYSPATH
     * with the actual var. i.e.
     * 
     * /var/www/site/app/Http/Controllers/Home.php
     * 
     * becomes:
     * 
     * APPPATH/Http/Controllers/Home.php
     * 
     * @param  string  $file
     * 
     * @return string
     */
    protected function cleanFileNames(string $file)
    {
        $file = str_replace(APP_PATH, 'APPPATH/', $file);
        $file = str_replace(SYS_PATH, 'SYSPATH/', $file);
        
        return $file;
    }

    /**
     * Handles logging the message.
     * 
     * @param  string  $level
     * @param  string  $message
     * 
     * @return bool
     */
    public function handle($level, $message)
    {        
        $path = $this->logFilePath.'lenevor-'.date('Y-m-d').'.'.$this->logFileExtension;

        if ( ! is_file($path)) {
            $newFile = true;

The assignment to $newFile is dead and can be removed.

            if ($this->logFileExtension === 'php') {
                $this->logMessage .= "<?php // Log file was generated ?>\n\n";
            }
        }

        $this->open($path);

        $this->logMessage($level, $message);
        
        flock($this->logHandler, LOCK_EX);

It seems like $this->logHandler can also be of type false; however, parameter $stream of flock() does only seem to accept resource, maybe add an additional type check?

        
        for ($written = 0, $length = strlen($this->logMessage); $written < $length; $written += $result) {
            if (($result = fwrite($this->logHandler, substr($this->logMessage, $written))) === false) {

It seems like $this->logHandler can also be of type false; however, parameter $stream of fwrite() does only seem to accept resource, maybe add an additional type check?

                // if we get this far, we'll never see this during travis-ci
                // @codeCoverageIgnoreStart
                break;
                // @codeCoverageIgnoreEnd
            }
        }
        
        flock($this->logHandler, LOCK_UN);
        
        if (isset($newfile) && $newfile === true) {

The variable $newfile does not exist. Did you maybe mean $newFile?

            chmod($path, $this->logFilePermissions);
        }
        
        return is_int($result);

The variable $result does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * Opens the current file.
     * 
     * @param  string  $path
     * 
     * @return bool
     */
    private function open($path)
    {
        if (false === $this->logHandler = is_resource($path) ? $path : @fopen($path, 'ab')) {

It seems like is_resource($path) ? $path : @fopen($path, 'ab') of type false or resource is incompatible with the declared type string of property $logHandler.

The condition is_resource($path) is always false.

            throw new LogException(sprintf('Unable to open "%s".', $path));
        }

        return true;
    }

    /**
     * Write message of log file.
     * 
     * @param  mixed  $level
     * @param  string  $messsage
     * 
     * @return $this
     */
    private function logMessage($level, $message)
    {
        $level = $this->getLogEnvironment().'.'.strtolower($level);

        $message = ucfirst($message);

        $this->logMessage .= "[{$this->getTimestamp()}] [{$level}] {$message}\n";

        return $this;
    }

    /**
     * Gets the correctly formatted Date/Time for the log entry.
     * 
     * PHP DateTime is dump, and you have to resort to trickery to get microseconds
     * to work correctly, so here it is.
     * 
     * @return string
     */
    private function getTimestamp()
    {
        $logDateFormat = $this->app['config']['logger.dateFormat'] ?? $this->logDateFormat;
        $originalTime  = microtime(true);
        $micro         = sprintf("%06d", ($originalTime - floor($originalTime)) * 1000000);

It seems like $originalTime can also be of type string; however, parameter $num of floor() does only seem to accept double|integer, maybe add an additional type check?

        $date          = new Chronos(date('Y-m-d H:i:s.'.$micro, $originalTime));

$originalTime of type double|string is incompatible with the type integer|null expected by parameter $timestamp of date().

        
        return $date->format($logDateFormat);
    }   
}