TechDeCo\ElasticApmAgent\Client\HttplugAsyncClient

Complexity

Total Complexity

14

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	sendTransaction()	0	11	1
A	sendError()	0	11	1
A	sendRequest()	0	21	3
B	waitForResponses()	0	24	4
A	verifyResponse()	0	11	4

<?php
declare(strict_types=1);

namespace TechDeCo\ElasticApmAgent\Client;

use Http\Client\HttpAsyncClient;
use Http\Discovery\Exception as DiscoveryException;
use Http\Discovery\HttpAsyncClientDiscovery;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Message\MessageFactory;
use Http\Promise\Promise;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\LoggerInterface;
use TechDeCo\ElasticApmAgent\Client;
use TechDeCo\ElasticApmAgent\ClientConfiguration;
use TechDeCo\ElasticApmAgent\Exception\ClientException;
use TechDeCo\ElasticApmAgent\Request\Error;
use TechDeCo\ElasticApmAgent\Request\Transaction;
use Throwable;
use function count;
use function json_encode;
use function register_shutdown_function;

final class HttplugAsyncClient implements Client
{
    /**
     * @var ClientConfiguration
     */
    private $config;

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

    /**
     * @var MessageFactory
     */
    private $httpMessageFactory;

    /**
     * @var Promise[]
     */
    private $promiseList = [];

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

    /**
     * @throws DiscoveryException
     */
    public function __construct(
        LoggerInterface $logger,
        ClientConfiguration $config,
        ?HttpAsyncClient $httpClient,
        ?MessageFactory $httpMessageFactory
    ) {
        $this->logger             = $logger;
        $this->config             = $config;
        $this->httpClient         = $httpClient ?? HttpAsyncClientDiscovery::find();
        $this->httpMessageFactory = $httpMessageFactory ?? MessageFactoryDiscovery::find();

        register_shutdown_function([$this, 'waitForResponses']);
    }

    /**
     * @throws ClientException
     */
    public function sendTransaction(Transaction $transaction): void
    {
        $request = $this->httpMessageFactory->createRequest(
            'POST',
            $this->config->getTransactionsEndpoint(),
            [],
            json_encode($transaction)
        );

        $this->sendRequest($request);
    }

    /**
     * @throws ClientException
     */
    public function sendError(Error $error): void
    {
        $request = $this->httpMessageFactory->createRequest(
            'POST',
            $this->config->getErrorsEndpoint(),
            [],
            json_encode($error)
        );

        $this->sendRequest($request);
    }

    /**
     * @throws ClientException
     */
    private function sendRequest(RequestInterface $request): void
    {
        try {
            $requestCount = count($this->promiseList) + 1;

            $request = $request->withHeader('Content-Type', 'application/json');

Consider using a different name than the parameter $request. This often makes code more readable.

            if ($this->config->needsAuthentication()) {
                $this->logger->debug('Adding authentication token to request');
                $request = $request->withHeader('Authorization', 'Bearer ' . $this->config->getToken());

Consider using a different name than the parameter $request. This often makes code more readable.

            }

            $this->logger->debug('Sending asynchronous request #' . $requestCount);
            $this->promiseList[] = $this->httpClient->sendAsyncRequest($request);
        } catch (Throwable $e) {
            $this->logger->error('Encountered error while sending asynchronous request #' . $requestCount, [
                'exception' => $e,
                'message' => $e->getMessage(),
            ]);
            throw new ClientException('Could not send request due to configuration error', 0, $e);
        }
    }

    /**
     * @throws ClientException
     */
    public function waitForResponses(): void
    {
        $exceptionList = [];
        foreach ($this->promiseList as $index => $promise) {
            try {
                $requestCount = $index + 1;
                $this->logger->debug('Waiting for response on request #' . $requestCount);
                $this->verifyResponse($promise->wait());
                $this->logger->debug('Successful response on request #' . $requestCount);
            } catch (Throwable $e) {
                $this->logger->error('Encountered error in response for request #' . $requestCount, [
                    'exception' => $e,
                    'message' => $e->getMessage(),
                ]);
                $exceptionList[] = $e;
            }
        }

        $this->promiseList = [];

        if (! empty($exceptionList)) {
            throw ClientException::fromException('Encountered errors while resolving requests', ...$exceptionList);
        }
    }

    /**
     * @throws ClientException
     */
    private function verifyResponse(ResponseInterface $response): void
    {
        $status = $response->getStatusCode();

        if ($status >= 400 && $status < 500) {
            throw ClientException::fromResponse('Bad request', $response);
        }
        if ($status >= 500) {
            throw ClientException::fromResponse('APM internal server error', $response);
        }
    }
}