Abacaphiliac\Doctrine\PsrSqlLoggerConfigurableLogLevels

Complexity

Total Complexity

10

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getStartQueryCallable()	0	14	2
A	getLoggerCallable()	0	4	1
A	getStartQueryContext()	0	7	1
A	stopQuery()	0	12	1
A	getStopQueryCallable()	0	4	1
A	__construct()	0	10	1
A	startQuery()	0	13	1
A	getApplicableLogLevel()	0	6	2

<?php

namespace Abacaphiliac\Doctrine;

use Doctrine\DBAL\Logging\SQLLogger;
use InvalidArgumentException;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;
use function array_merge;
use function call_user_func;
use function is_callable;
use function microtime;
use function uniqid;

final class PsrSqlLoggerConfigurableLogLevels implements SQLLogger
{
    /** @var LoggerInterface */
    private $logger;

    /** @var float */
    private $start;

    /** @var callable */
    private $startQueryCallable;

    /** @var string */
    private $queryId;

    /** @var string */
    private $defaultLogLevel;

    /** @var LogLevelConfiguration|null */
    private $logLevelConfiguration;

    public function __construct(
        LoggerInterface $logger,
        LogLevelConfiguration $logLevelMapping,
        string $defaultLogLevel = LogLevel::INFO
    ) {
        $this->logger                = $logger;
        $this->logLevelConfiguration = $logLevelMapping;
        $this->defaultLogLevel       = $defaultLogLevel;
        $this->startQueryCallable    = $this->getStartQueryCallable($defaultLogLevel);
    }

    private function getStartQueryCallable(string $level): callable
    {
        $callable = $this->getLoggerCallable($level);

        if (!is_callable($callable)) {
            throw new InvalidArgumentException(sprintf(
                '%s::%s" is not callable',
                LoggerInterface::class,
                $this->defaultLogLevel
            ));
        }

        return $callable;
    }

    private function getLoggerCallable(string $level) : array
    {
        return [$this->logger, $level];
    }

    public function startQuery($sql, array $params = null, array $types = null) : void
    {
        $this->queryId = uniqid('', true);

        $this->start = microtime(true);

        call_user_func($this->startQueryCallable, 'Query started', array_merge(
            $this->getStartQueryContext($sql, $params, $types),
            [
                'query_id' => $this->queryId,
            ]
        ));
    }

    protected function getStartQueryContext($sql, array $params = null, array $types = null) : array

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

    {
        return [
            'sql' => $sql,
            'types' => $types,
        ];
    }

    public function stopQuery() : void
    {
        $stop = microtime(true);
        $durationInSeconds = $stop - $this->start;

        call_user_func($this->getStopQueryCallable($durationInSeconds), 'Query finished', [
            'query_id' => $this->queryId,
            'start' => $this->start,
            'stop' => $stop,
            'duration_s' => $durationInSeconds,
        ]);
    }

    private function getStopQueryCallable(float $durationInSeconds): callable
    {
        return $this->getLoggerCallable($this->getApplicableLogLevel($durationInSeconds) ?? $this->defaultLogLevel);
    }

    private function getApplicableLogLevel(float $durationInSeconds): ?string
    {
        return $this->logLevelConfiguration instanceof LogLevelConfiguration
            ? $this->logLevelConfiguration->getApplicableLogLevel($durationInSeconds)
            : $this->defaultLogLevel;
    }
}