Nip\Logger\Manager\CreateDrivers

Complexity

Total Complexity

11

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Test Coverage

Coverage

69.23%

Importance

Changes	1
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	resolve()	0	19	4
A	createEmergencyLogger()	0	11	1
A	initDriver()	0	5	1
A	callCustomCreator()	0	3	1
A	createStackDriver()	0	14	2
A	createSingleDriver()	0	17	2

<?php

namespace Nip\Logger\Manager;

use Monolog\Handler\HandlerInterface;
use Monolog\Handler\StreamHandler;
use Monolog\Logger as Monolog;
use Nip\Config\Config;
use Psr\Log\InvalidArgumentException;

/**
 * Trait CreateDrivers
 * @package Nip\Logger\Traits
 */
trait CreateDrivers
{

    /**
     * The registered custom driver creators.
     *
     * @var array
     */
    protected $customCreators = [];

    /**
     * @param $name
     * @return mixed
     */
    protected function initDriver($name)
    {
        $this->channels[$name] = $this->createLogger($this->resolve($name));

The property channels does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

It seems like createLogger() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $this->channels[$name];
    }

    /**
     * Resolve the given log instance by name.
     *
     * @param string $name
     * @return \Psr\Log\LoggerInterface
     *
     * @throws \InvalidArgumentException
     */
    protected function resolve($name)
    {
        $config = $this->configurationFor($name);

It seems like configurationFor() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        if (is_null($config)) {
            throw new InvalidArgumentException("Log [{$name}] is not defined.");
        }

        if (isset($this->customCreators[$config['driver']])) {
            return $this->callCustomCreator($config);
        }

        $driverMethod = 'create'.ucfirst($config['driver']).'Driver';

        if (method_exists($this, $driverMethod)) {
            return $this->{$driverMethod}($config);
        }

        throw new InvalidArgumentException("Driver [{$config['driver']}] is not supported.");
    }

    /**
     * Call a custom driver creator.
     *
     * @param array $config
     * @return mixed
     */
    protected function callCustomCreator(array $config)
    {
        return $this->customCreators[$config['driver']]($this->app, $config);
    }

    /**
     * Create an aggregate log driver instance.
     *
     * @param array $config
     * @return \Psr\Log\LoggerInterface
     */
    protected function createStackDriver($config)
    {
        $config = $config instanceof Config ? $config->toArray() : $config;

$config is never a sub-type of Nip\Config\Config.

        $handlers = [];
        array_map(function ($channel) use (&$handlers) {
            $handlers = array_merge($handlers, $this->channel($channel)->getHandlers());

It seems like channel() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }, $config['channels']);

//        if ($config['ignore_exceptions'] ?? false) {
//            $handlers = [new WhatFailureGroupHandler($handlers)];
//        }

        return new Monolog($this->parseChannel($config), $handlers);

It seems like parseChannel() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Create an instance of the single file log driver.
     *
     * @param array $config
     * @return \Psr\Log\LoggerInterface
     */
    protected function createSingleDriver($config)
    {
        $config = $config instanceof Config ? $config->toArray() : $config;

$config is never a sub-type of Nip\Config\Config.

        $handlers = [
            $this->prepareHandler(

It seems like prepareHandler() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                new StreamHandler(
                    $config['path'] ?? $this->getLogsFolderPath().'/bytic.log',

It seems like getLogsFolderPath() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                    $this->level($config),

It seems like level() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                    $config['bubble'] ?? true,
                    $config['permission'] ?? null,
                    $config['locking'] ?? false
                ),
                $config
            ),
        ];

        return new Monolog($this->parseChannel($config), $handlers);
    }

    /**
     * Create an emergency log handler to avoid white screens of death.
     *
     * @return \Psr\Log\LoggerInterface
     */
    protected function createEmergencyLogger()
    {
        $config = $this->configurationFor('emergency');

        $handler = new StreamHandler(
            $config['path'] ?? $this->getLogsFolderPath().'/bytic.log',
            $this->level(['level' => 'debug'])
        );

        return $this->createLogger(
            new Monolog('bytic', $this->prepareHandlers([$handler]))

It seems like prepareHandlers() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        );
    }
}