SevenShores\Hubspot\Http\Client::request()

Complexity

Conditions	22
Paths	784

Size

Total Lines

97

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function request($method, $endpoint, $options = [], $query_string = null, $requires_auth = true)
    {
        $url = $this->generateUrl($endpoint, $query_string, $requires_auth);

        $options = array_merge($this->clientOptions, $options);
        $options["headers"]["User-Agent"] = $this->user_agent;

        if ($this->oauth2) {
            $options["headers"]["Authorization"] = "Bearer " . $this->key;
        }

        try {
            $keepTrying = true;

$keepTrying is not used, you could remove the assignment.

            $exceptionCounter = 0;
            if($this->handleRateLimits
                && !is_null($this->requestsRemainingThisSecond)
                && (
                    ($this->requestsRemainingThisSecond <= 1)
                    ||
                    (($this->requestsRemainingThisSecond <= 2)
                        && ($this->requestsRemainingThisSecondTime == time()))
                )
            ){
                usleep($this->backOffDelay);
            }
            do {
                try {
                    $response = $this->client->request($method, $url, $options);
                    $keepTrying = false;
                } catch (\GuzzleHttp\Exception\BadResponseException $e) {
                    if(!$this->handleRateLimits) {
                        throw $e;
                    }
                    switch ($e->getCode()) {
                        /**
                         * @see https://developers.hubspot.com/docs/faq/api-error-responses
                         *
                         * 500 This is not documented but it happens. Seems like its part of the rate limiting but they
                         * choose this instead of 429 in some cases. If the message is "internal error" then that means
                         * we have to backoff, otherwise re-throw the user error for them to handle it
                         */
                        case 500:
                            if(strpos($e->getMessage(),'"message":"internal error"') === false) {
                                throw $e;
                            }
                        /**
                         * 502/504 timeouts - HubSpot has processing limits in place to prevent a single client causing
                         * degraded performance, and these responses indicate that those limits have been hit.
                         * You'll normally only see these timeout responses when making a a large number of requests
                         * over a sustained period.  If you get one of these responses, you should pause your requests
                         * for a few seconds, then retry.
                         */
                        case 502:
                        case 504:
                            /**
                             * 429 Too many requests - Returned when your portal or app is over the API rate limits.
                             * Please see this document for details on those rate limits and suggestions for working within
                             * those limits.
                             */
                        case 429:
                            $matches = [];
                            preg_match('/X-HubSpot-RateLimit-Daily-Remaining: (\d+)/', $e->getMessage(), $matches);
                            if(isset($matches[1])) {
                                $dailyLimitLeft = (int)$matches[1];
                                if($dailyLimitLeft === 0) {
                                    throw $e;
                                }
                            }
                            $exceptionCounter++;
                            if ($exceptionCounter >= $this->exceptionMax) {
                                throw $e;
                            }
                            usleep($this->exceptionDelay);
                            $keepTrying = true;
                            break;
                        default: // Throw to outer handler
                            throw $e;
                    }
                }
            } while ($keepTrying === true);

            // Check headers for delay
            if($this->handleRateLimits) {
                $this->requestsRemainingThisSecond = (int)$response->getHeader('X-HubSpot-RateLimit-Secondly-Remaining')[0];
                $this->requestsRemainingThisSecondTime = time();
            }

            if ($this->wrapResponse === false) {
                return $response;
            }
            return new Response($response);
        } catch (\GuzzleHttp\Exception\BadResponseException $e) {
            throw new BadRequest(\GuzzleHttp\Psr7\str($e->getResponse()), $e->getCode(), $e);

It seems like $e->getResponse() can be null; however, GuzzleHttp\Psr7\str() does not accept null, maybe add an additional type check?

        } catch (\Exception $e) {
            throw new BadRequest($e->getMessage(), $e->getCode(), $e);
        }
    }