Spiral\Monolog\LogFactory

Complexity

Total Complexity

11

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	getHandlers()	0	21	4
A	getProcessors()	0	3	1
A	getLogger()	0	19	4
A	createInjection()	0	4	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Monolog;

use Monolog\Handler\HandlerInterface;
use Monolog\Logger;
use Monolog\Processor\PsrLogMessageProcessor;
use Psr\Container\ContainerExceptionInterface;
use Psr\Log\LoggerInterface;
use Spiral\Core\Container\Autowire;
use Spiral\Core\Container\InjectorInterface;
use Spiral\Core\FactoryInterface;
use Spiral\Logger\ListenerRegistryInterface;
use Spiral\Logger\LogsInterface;
use Spiral\Monolog\Config\MonologConfig;
use Spiral\Monolog\Exception\ConfigException;

final class LogFactory implements LogsInterface, InjectorInterface
{
    // Default logger channel (supplied via injection)
    public const DEFAULT = 'default';

    /** @var MonologConfig */
    private $config;

    /** @var LoggerInterface */
    private $default;

    /** @var FactoryInterface */
    private $factory;

    /** @var HandlerInterface|null */
    private $eventHandler;

    /**
     * @param MonologConfig             $config
     * @param ListenerRegistryInterface $listenerRegistry
     * @param FactoryInterface          $factory
     */
    public function __construct(
        MonologConfig $config,
        ListenerRegistryInterface $listenerRegistry,
        FactoryInterface $factory
    ) {
        $this->config = $config;
        $this->factory = $factory;
        $this->eventHandler = new EventHandler($listenerRegistry, $config->getEventLevel());
    }

    /**
     * @inheritdoc
     */
    public function getLogger(string $channel = null): LoggerInterface
    {
        if ($channel === null || $channel == self::DEFAULT) {
            if ($this->default !== null) {
                // we should use only one default logger per system
                return $this->default;
            }

            return $this->default = new Logger(
                self::DEFAULT,
                $this->getHandlers(self::DEFAULT),
                $this->getProcessors(self::DEFAULT)
            );
        }

        return new Logger(
            $channel,
            $this->getHandlers($channel),
            $this->getProcessors($channel)
        );
    }

    /**
     * @inheritdoc
     */
    public function createInjection(\ReflectionClass $class, string $context = null)
    {
        // always return default logger as injection
        return $this->getLogger();
    }

    /**
     * Get list of channel specific handlers.
     *
     * @param string $channel
     * @return array
     *
     * @throws ConfigException
     */
    protected function getHandlers(string $channel): array
    {
        // always include default handler
        $handlers = [];

        foreach ($this->config->getHandlers($channel) as $handler) {
            if (!$handler instanceof Autowire) {
                $handlers[] = $handler;
                continue;
            }

            try {
                $handlers[] = $handler->resolve($this->factory);
            } catch (ContainerExceptionInterface $e) {
                throw new ConfigException($e->getMessage(), $e->getCode(), $e);

The method getCode() does not exist on Psr\Container\ContainerExceptionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Psr\Container\NotFoundExceptionInterface. Are you sure you never get one of those?

The method getMessage() does not exist on Psr\Container\ContainerExceptionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Psr\Container\NotFoundExceptionInterface. Are you sure you never get one of those?

            }
        }

        $handlers[] = $this->eventHandler;

        return $handlers;
    }

    /**
     * Get list of channel specific log processors. Falls back to PsrLogMessageProcessor for now.
     *
     * @param string $channel
     * @return callable[]
     */
    protected function getProcessors(string $channel): array

The parameter $channel is not used and could be removed.

    {
        return [new PsrLogMessageProcessor()];
    }
}