Implemented Exponential Backoff for RateExceededError

Author: schulzefelix

CHANGELOG.md

@@ -5,6 +5,7 @@ All Notable changes to `Laravel AdWords Targeting Idea Service` will be document
 ## [1.3.4] - 2019-02-27
 - Add compatibility with Laravel 5.8
 - Using version 40.0 of googleads/googleads-php-lib
+- Implemented Exponential Backoff for RateExceededError
 
 ## [1.3.3] - 2018-10-30
 - Using version 37.1.0 of googleads/googleads-php-lib

src/AdWordsService.php

@@ -58,22 +58,9 @@ public function performQuery(array $keywords, $requestType, $language = null, $l
         $selector->setPaging(new Paging(0, self::PAGE_LIMIT));
         $selector->setSearchParameters($this->getSearchParameters($keywords, $language, $location, $included, $excluded));
 
-        $currentTry = 0;
-
-        while (true) {
-            try {
-                $results = $this->targetingIdeaService->get($selector);
-
-                return $results;
-            } catch (ApiException $exception) {
-                $error = $exception->getErrors()[0];
-                if ($error instanceof RateExceededError and ++$currentTry < self::MAX_RETRIES) {
-                    sleep($error->getRetryAfterSeconds());
-                } else {
-                    throw $exception;
-                }
-            }
-        }
+        return (new ExponentialBackoff(10))->execute(function () use ($selector) {
+            return $this->targetingIdeaService->get($selector);
+        });
     }
 
     /**

src/ExponentialBackoff.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace SchulzeFelix\AdWords;
+
+/**
+ * Exponential backoff implementation.
+ */
+class ExponentialBackoff
+{
+    const MAX_DELAY_MICROSECONDS = 120000000;
+
+    /**
+     * @var int
+     */
+    private $retries;
+
+    /**
+     * @var callable
+     */
+    private $retryFunction;
+
+    /**
+     * @var callable
+     */
+    private $delayFunction;
+
+    /**
+     * @param int $retries [optional] Number of retries for a failed request.
+     * @param callable $retryFunction [optional] returns bool for whether or not to retry
+     */
+    public function __construct($retries = null, callable $retryFunction = null)
+    {
+        $this->retries = $retries !== null ? (int) $retries : 3;
+        $this->retryFunction = $retryFunction;
+        $this->delayFunction = function ($delay) {
+            usleep($delay);
+        };
+    }
+
+    /**
+     * Executes the retry process.
+     *
+     * @param callable $function
+     * @param array $arguments [optional]
+     * @return mixed
+     * @throws \Exception The last exception caught while retrying.
+     */
+    public function execute(callable $function, array $arguments = [])
+    {
+        $delayFunction = $this->delayFunction;
+        $retryAttempt = 0;
+        $exception = null;
+
+        while (true) {
+            try {
+                return call_user_func_array($function, $arguments);
+            } catch (\Exception $exception) {
+                if ($this->retryFunction) {
+                    if (! call_user_func($this->retryFunction, $exception)) {
+                        throw $exception;
+                    }
+                }
+
+                if ($exception->getCode() == 403) {
+                    break;
+                }
+
+                if ($retryAttempt >= $this->retries) {
+                    break;
+                }
+
+                $delayFunction($this->calculateDelay($retryAttempt));
+                $retryAttempt++;
+            }
+        }
+
+        throw $exception;
+    }
+
+    /**
+     * @param callable $delayFunction
+     * @return void
+     */
+    public function setDelayFunction(callable $delayFunction)
+    {
+        $this->delayFunction = $delayFunction;
+    }
+
+    /**
+     * Calculates exponential delay.
+     *
+     * @param int $attempt
+     * @return int
+     */
+    private function calculateDelay($attempt)
+    {
+        return min(
+            mt_rand(0, 1000000) + (pow(2, $attempt) * 1000000),
+            self::MAX_DELAY_MICROSECONDS
+        );
+    }
+}