Spiral\Monolog\Bootloader\MonologBootloader

Complexity

Total Complexity

10

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Test Coverage

Coverage

74.42%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	addHandler()	0	12	2
A	__construct()	0	3	1
A	init()	0	31	6
A	logRotate()	0	17	1

<?php

declare(strict_types=1);

namespace Spiral\Monolog\Bootloader;

use Monolog\Formatter\LineFormatter;
use Monolog\Handler\HandlerInterface;
use Monolog\Handler\RotatingFileHandler;
use Monolog\Logger;
use Monolog\ResettableInterface;
use Psr\Log\LoggerInterface;
use Spiral\Boot\Bootloader\Bootloader;
use Spiral\Boot\EnvironmentInterface;
use Spiral\Boot\FinalizerInterface;
use Spiral\Config\ConfiguratorInterface;
use Spiral\Config\Patch\Append;
use Spiral\Core\Container;
use Spiral\Logger\LogsInterface;
use Spiral\Monolog\Config\MonologConfig;
use Spiral\Monolog\LogFactory;

final class MonologBootloader extends Bootloader implements Container\SingletonInterface
{
    protected const SINGLETONS = [
        LogsInterface::class => LogFactory::class,
        LoggerInterface::class => Logger::class,
    ];

    protected const BINDINGS = [
        'log.rotate' => [self::class, 'logRotate'],
    ];

    public function __construct(
        private readonly ConfiguratorInterface $config
    ) {
    }

    public function init(Container $container, FinalizerInterface $finalizer, EnvironmentInterface $env): void
    {
        $finalizer->addFinalizer(static function (bool $terminate) use ($container): void {
            if ($terminate) {
                return;
            }

            if ($container->hasInstance(LoggerInterface::class)) {
                $logger = $container->get(LoggerInterface::class);

                if ($logger instanceof ResettableInterface) {
                    $logger->reset();
                }
            }

            if ($container->hasInstance(LogsInterface::class)) {
                $factory = $container->get(LogsInterface::class);

                if ($factory instanceof ResettableInterface) {
                    $factory->reset();
                }
            }
        });

        $this->config->setDefaults(MonologConfig::CONFIG, [
            'default' => $env->get('MONOLOG_DEFAULT_CHANNEL', MonologConfig::DEFAULT_CHANNEL),
            'globalLevel' => Logger::DEBUG,
            'handlers' => [],
        ]);

        $container->bindInjector(Logger::class, LogFactory::class);
    }

    public function addHandler(string $channel, HandlerInterface $handler): void
    {
        if (!isset($this->config->getConfig(MonologConfig::CONFIG)['handlers'][$channel])) {
            $this->config->modify(MonologConfig::CONFIG, new Append('handlers', $channel, []));
        }

        $this->config->modify(
            MonologConfig::CONFIG,
            new Append(
                'handlers.' . $channel,
                null,
                $handler
            )
        );
    }

    public function logRotate(
        string $filename,
        int $level = Logger::DEBUG,
        int $maxFiles = 0,
        bool $bubble = false
    ): HandlerInterface {
        $handler = new RotatingFileHandler(
            $filename,
            $maxFiles,
            $level,
            $bubble,
            null,
            true
        );

        return $handler->setFormatter(
            new LineFormatter("[%datetime%] %level_name%: %message% %context%\n")
        );
    }
}