WyriHaximus\React\PSR3\Loggly\LogglyLogger

Complexity

Total Complexity

20

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

95.08%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	10	1
A	createFromHttpClient()	0	4	1
A	__construct()	0	5	1
A	log()	0	12	2
A	format()	0	18	2
B	processPlaceHolders()	0	19	8
A	normalizeContext()	0	15	4
A	send()	0	12	1

<?php declare(strict_types=1);

namespace WyriHaximus\React\PSR3\Loggly;

use Psr\Log\AbstractLogger;
use Psr\Log\InvalidArgumentException;
use Psr\Log\LogLevel;
use React\Dns\Resolver\Factory as ResolverFactory;
use React\EventLoop\LoopInterface;
use React\HttpClient\Client;
use React\HttpClient\Factory as HttpClientFactory;

final class LogglyLogger extends AbstractLogger
{
    /**
     * Logging levels PSR-3 LogLevel enum
     *
     * @var array $levels Logging levels
     */
    const LOG_LEVELS = [
        LogLevel::DEBUG     => 'DEBUG',
        LogLevel::INFO      => 'INFO',
        LogLevel::NOTICE    => 'NOTICE',
        LogLevel::WARNING   => 'WARNING',
        LogLevel::ERROR     => 'ERROR',
        LogLevel::CRITICAL  => 'CRITICAL',
        LogLevel::ALERT     => 'ALERT',
        LogLevel::EMERGENCY => 'EMERGENCY',
    ];

    /**
     * @var Client
     */
    private $httpClient;

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

    public static function create(LoopInterface $loop, string $token): self
    {
        $resolverFactory = new ResolverFactory();
        $resolver = $resolverFactory->create('8.8.8.8', $loop);

        $factory = new HttpClientFactory();
        $httpClient = $factory->create($loop, $resolver);

        return new self($httpClient, $token);
    }

    public static function createFromHttpClient(Client $httpClient, string $token): self
    {
        return new self($httpClient, $token);
    }

    private function __construct(Client $httpClient, string $token)
    {
        $this->httpClient = $httpClient;
        $this->token = $token;
    }

    public function log($level, $message, array $context = [])
    {
        $levels = self::LOG_LEVELS;
        if (!isset($levels[$level])) {
            throw new InvalidArgumentException(
                'Level "'.$level.'" is not defined, use one of: '.implode(', ', array_keys(self::LOG_LEVELS))
            );
        }

        $data = $this->format($level, $message, $context);
        $this->send($data);
    }

    protected function format($level, $message, array $context): string
    {
        $message = (string)$message;
        $context = $this->normalizeContext($context);
        $message = $this->processPlaceHolders($message, $context);
        $json = json_encode([
            'level'   => $level,
            'message' => $message,
            'level_message' => $level . ' ' . $message,
            'context' => $context,
        ]);

        if ($json === false) {
            throw new InvalidArgumentException(json_last_error_msg());
        }

        return $json;
    }

    /**
     * @param string $message
     * @param array $context
     * @return string
     *
     * Method copied from: https://github.com/Seldaek/monolog/blob/6e6586257d9fb231bf039563632e626cdef594e5/src/Monolog/Processor/PsrLogMessageProcessor.php
     */
    private function processPlaceHolders(string $message, array $context): string
    {
        if (false === strpos($message, '{')) {
            return $message;
        }

        $replacements = array();
        foreach ($context as $key => $val) {
            if (is_null($val) || is_scalar($val) || (is_object($val) && method_exists($val, '__toString'))) {
                $replacements['{'.$key.'}'] = $val;
            } elseif (is_object($val)) {
                $replacements['{'.$key.'}'] = '[object '.get_class($val).']';
            } else {
                $replacements['{'.$key.'}'] = '['.gettype($val).']';
            }
        }

        return strtr($message, $replacements);
    }

    private function normalizeContext(array $context): array
    {
        foreach ($context as $index => $value) {
            if (is_array($value)) {
                $context[$index] = $this->normalizeContext($value);
                continue;
            }

            if (is_resource($value)) {
                $context[$index] = sprintf('[resource] (%s)', get_resource_type($value));
                continue;
            }
        }
        return $context;
    }

    protected function send(string $data)
    {
        $this->httpClient->request(
            'POST',
            'https://logs-01.loggly.com/inputs/' . $this->token,
            [
                'Content-Type' => 'application/json',
                'Content-Length' => strlen($data),
            ],
            '1.1'
        )->end($data);
    }
}