Add retry support

.generator/src/generator/cli.py

@@ -87,6 +87,7 @@ def cli(specs, output):
         "PaginationIterator.java": env.get_template("PaginationIterator.j2"),
         "UnparsedObject.java": env.get_template("UnparsedObject.j2"),
         "ZstdEncoder.java": env.get_template("ZstdEncoder.j2"),
+        "RetryConfig.java": env.get_template("RetryConfig.j2"),
     }
 
     auth_files = {

.generator/src/generator/templates/ApiClient.j2

@@ -78,6 +78,7 @@ import {{ common_package_name }}.ApiException;
 import {{ common_package_name }}.ApiResponse;
 import {{ common_package_name }}.JSON;
 import {{ common_package_name }}.Pair;
+import {{ common_package_name }}.RetryConfig;
 import {{ common_package_name }}.RFC3339DateFormat;
 import {{ common_package_name }}.ServerConfiguration;
 import {{ common_package_name }}.ServerVariable;
@@ -162,6 +163,7 @@ public class ApiClient {
   protected Map<String, Integer> operationServerIndex = new HashMap<String, Integer>();
   protected Map<String, Map<String, String>> operationServerVariables = new HashMap<String, Map<String, String>>();
   protected boolean debugging = false;
+  protected RetryConfig retry = new RetryConfig(false, 2, 2, 3);
   protected boolean compress = true;
   protected ClientConfig clientConfig;
   protected int connectionTimeout = 0;
@@ -288,6 +290,30 @@ public class ApiClient {
     return offsetDateTimeFormatter;
   }
 
+  /** 
+   * Add custom retry object in the client
+   * @param retry retry object
+   * */
+  public void setRetry(RetryConfig retry) {
+    this.retry = retry;
+  }
+
+  /**
+   * Return the retryConfig object 
+   * @return retryConfig
+   */
+  public RetryConfig getRetry() {
+    return retry;
+  }
+
+  /**
+  * Enable retry directly on the client instead of creating a new retry object
+  * @param enableRetry bool, enable retry or not
+  */
+  public void enableRetry(boolean enableRetry){
+    this.retry.setEnableRetry(enableRetry);
+  }
+
   /**
    * Set the date format used to parse/format {@code OffsetDateTime} parameters.
    *
@@ -1229,45 +1255,76 @@ public class ApiClient {
       throws ApiException {
 
     String contentEncoding = headerParams.get(HttpHeaders.CONTENT_ENCODING);
-    Entity<?> entity = serialize(body, formParams, selectHeaderContentType(contentTypes), contentEncoding, isBodyNullable);
+    Entity<?> entity =
+        serialize(
+            body,
+            formParams,
+            selectHeaderContentType(contentTypes),
+            contentEncoding,
+            isBodyNullable);
 
     Response response = null;
 
     try {
-      response = sendRequest(method, invocationBuilder, entity);
-
-      int statusCode = response.getStatusInfo().getStatusCode();
-      Map<String, List<String>> responseHeaders = buildResponseHeaders(response);
-
-      if (response.getStatusInfo() == Status.NO_CONTENT) {
-        return new ApiResponse<T>(statusCode, responseHeaders);
-      } else if (response.getStatusInfo().getFamily() == Status.Family.SUCCESSFUL) {
-        if (returnType == null) {
+      int currentRetry = 0;
+      while (true){
+        response = sendRequest(method, invocationBuilder, entity);
+        int statusCode = response.getStatusInfo().getStatusCode();
+        Map<String, List<String>> responseHeaders = buildResponseHeaders(response);
+        if (response.getStatusInfo() == Status.NO_CONTENT) {
           return new ApiResponse<T>(statusCode, responseHeaders);
+        } else if (response.getStatusInfo().getFamily() == Status.Family.SUCCESSFUL) {
+          if (returnType == null) {
+            return new ApiResponse<T>(statusCode, responseHeaders);
+          } else {
+            return new ApiResponse<T>(statusCode, responseHeaders, deserialize(response, returnType));
+          }
+        } else if (shouldRetry(currentRetry, statusCode, retry)){
+            retry.sleepInterval(calculateRetryInterval(responseHeaders, retry, currentRetry));
+            currentRetry++;
         } else {
-          return new ApiResponse<T>(statusCode, responseHeaders, deserialize(response, returnType));
-        }
-      } else {
-        String message = "error";
-        String respBody = null;
-        if (response.hasEntity()) {
-          try {
-            respBody = String.valueOf(response.readEntity(String.class));
-            message = respBody;
-          } catch (RuntimeException e) {
-            // e.printStackTrace();
+          String message = "error";
+          String respBody = null;
+          if (response.hasEntity()) {
+            try {
+              respBody = String.valueOf(response.readEntity(String.class));
+              message = respBody;
+            } catch (RuntimeException e) {
+              // e.printStackTrace();
+            }
           }
-        }
-        throw new ApiException(
-            response.getStatus(), message, buildResponseHeaders(response), respBody);
-      }
+          throw new ApiException(
+              response.getStatus(), message, buildResponseHeaders(response), respBody);
+          }
+      } 
     } finally {
-      try {
-        response.close();
-      } catch (Exception e) {
-        // it's not critical, since the response object is local in method invokeAPI; that's fine,
-        // just continue
+        try {
+          response.close();
+        } catch (Exception e) {
+          // it's not critical, since the response object is local in method invokeAPI; that's fine,
+          // just continue
+          }
+      }
+  }
+
+  private boolean shouldRetry(int retryCount, int statusCode, RetryConfig retryConfig){
+    boolean statusToRetry = false;
+    if (statusCode == 429 || statusCode >= 500){
+      statusToRetry = true;
+    }
+    return (retryConfig.maxRetries>retryCount && statusToRetry && retryConfig.isEnableRetry());
+  }
+
+  private int calculateRetryInterval(Map<String, List<String>> responseHeaders, RetryConfig retryConfig, int retryCount){
+    if ( responseHeaders.get("x-ratelimit-reset")!=null){
+      List<String> rateLimitHeader = responseHeaders.get("x-ratelimit-reset");
+      return Integer.parseInt(rateLimitHeader.get(0));
+    } else {
+      int retryInterval= (int) Math.pow (retry.backOffMultiplier, retryCount)*  retryConfig.backOffBase;
+      if (getConnectTimeout()>0){
+        retryInterval = Math.min(retryInterval, getConnectTimeout());
       }
+      return retryInterval;
     }
   }
 

.generator/src/generator/templates/RetryConfig.j2

@@ -0,0 +1,64 @@
+{% include "ApiInfo.j2" %}
+
+package {{ common_package_name }};
+
+public class RetryConfig {
+  public boolean enableRetry;
+  public int backOffMultiplier;
+  public int backOffBase;
+  public int maxRetries;
+
+  /**
+   * @param enableRetry Enable retry when rate limited
+   * @param backOffMultiplier Multiplier for retry backoff
+   * @param backOffBase Base for retry backoff
+   * @param maxRetries Maximum number of retries
+   */
+  public RetryConfig(boolean enableRetry, int backOffMultiplier, int backOffBase, int maxRetries) {
+    this.enableRetry = enableRetry;
+    this.backOffMultiplier = backOffMultiplier;
+    this.backOffBase = backOffBase;
+    this.maxRetries = maxRetries;
+  }
+
+  public boolean isEnableRetry() {
+    return enableRetry;
+  }
+
+  public int getBackOffMultiplier() {
+    return backOffMultiplier;
+  }
+
+  public int getBackOffBase() {
+    return backOffBase;
+  }
+
+  public int getMaxRetries() {
+    return maxRetries;
+  }
+
+  public void setEnableRetry(boolean enableRetry) {
+    this.enableRetry = enableRetry;
+  }
+
+  public void setBackOffMultiplier(int backOffMultiplier) {
+    this.backOffMultiplier = backOffMultiplier;
+  }
+
+  public void setBackOffBase(int backOffBase) {
+    this.backOffBase = backOffBase;
+  }
+
+  public void setMaxRetries(int maxRetries) {
+    this.maxRetries = maxRetries;
+  }
+
+  public void sleepInterval(int sleepInterval) {
+    try {
+      Thread.sleep(sleepInterval * 1000);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      e.printStackTrace();
+    }
+  }
+}

README.md

@@ -168,6 +168,17 @@ If you want to enable requests logging, set the `debugging` flag on your client:
 defaultClient.setDebugging(true)
 ```
 
+### Enable Retry
+
+To enable the client to retry when rate limited (status 429) or status 500 and above:
+
+```java
+defaultClient.enableRetry(true)
+```
+
+The interval between 2 retry attempts will be the value of the `x-ratelimit-reset` response header when available. If not, it will be :
+`Math.pow (multiplier_for_retry_backoff, current_retry_count)*base_for_retry_backoff`.
+
 ### Configure proxy
 
 You can provide custom `connectorProvider` implemtation to `clientConfig` to use proxy. See example below using `ApacheConnectorProvider`:

src/main/java/com/datadog/api/client/ApiClient.java

@@ -350,6 +350,7 @@ public class ApiClient {
   protected Map<String, Map<String, String>> operationServerVariables =
       new HashMap<String, Map<String, String>>();
   protected boolean debugging = false;
+  protected RetryConfig retry = new RetryConfig(false, 2, 2, 3);
   protected boolean compress = true;
   protected ClientConfig clientConfig;
   protected int connectionTimeout = 0;
@@ -517,6 +518,33 @@ public DateTimeFormatter getOffsetDateTimeFormatter() {
     return offsetDateTimeFormatter;
   }
 
+  /**
+   * Add custom retry object in the client
+   *
+   * @param retry retry object
+   */
+  public void setRetry(RetryConfig retry) {
+    this.retry = retry;
+  }
+
+  /**
+   * Return the retryConfig object
+   *
+   * @return retryConfig
+   */
+  public RetryConfig getRetry() {
+    return retry;
+  }
+
+  /**
+   * Enable retry directly on the client instead of creating a new retry object
+   *
+   * @param enableRetry bool, enable retry or not
+   */
+  public void enableRetry(boolean enableRetry) {
+    this.retry.setEnableRetry(enableRetry);
+  }
+
   /**
    * Set the date format used to parse/format {@code OffsetDateTime} parameters.
    *
@@ -1525,32 +1553,37 @@ public <T> ApiResponse<T> invokeAPI(
     Response response = null;
 
     try {
-      response = sendRequest(method, invocationBuilder, entity);
-
-      int statusCode = response.getStatusInfo().getStatusCode();
-      Map<String, List<String>> responseHeaders = buildResponseHeaders(response);
-
-      if (response.getStatusInfo() == Status.NO_CONTENT) {
-        return new ApiResponse<T>(statusCode, responseHeaders);
-      } else if (response.getStatusInfo().getFamily() == Status.Family.SUCCESSFUL) {
-        if (returnType == null) {
+      int currentRetry = 0;
+      while (true) {
+        response = sendRequest(method, invocationBuilder, entity);
+        int statusCode = response.getStatusInfo().getStatusCode();
+        Map<String, List<String>> responseHeaders = buildResponseHeaders(response);
+        if (response.getStatusInfo() == Status.NO_CONTENT) {
           return new ApiResponse<T>(statusCode, responseHeaders);
+        } else if (response.getStatusInfo().getFamily() == Status.Family.SUCCESSFUL) {
+          if (returnType == null) {
+            return new ApiResponse<T>(statusCode, responseHeaders);
+          } else {
+            return new ApiResponse<T>(
+                statusCode, responseHeaders, deserialize(response, returnType));
+          }
+        } else if (shouldRetry(currentRetry, statusCode, retry)) {
+          retry.sleepInterval(calculateRetryInterval(responseHeaders, retry, currentRetry));
+          currentRetry++;
         } else {
-          return new ApiResponse<T>(statusCode, responseHeaders, deserialize(response, returnType));
-        }
-      } else {
-        String message = "error";
-        String respBody = null;
-        if (response.hasEntity()) {
-          try {
-            respBody = String.valueOf(response.readEntity(String.class));
-            message = respBody;
-          } catch (RuntimeException e) {
-            // e.printStackTrace();
+          String message = "error";
+          String respBody = null;
+          if (response.hasEntity()) {
+            try {
+              respBody = String.valueOf(response.readEntity(String.class));
+              message = respBody;
+            } catch (RuntimeException e) {
+              // e.printStackTrace();
+            }
           }
+          throw new ApiException(
+              response.getStatus(), message, buildResponseHeaders(response), respBody);
         }
-        throw new ApiException(
-            response.getStatus(), message, buildResponseHeaders(response), respBody);
       }
     } finally {
       try {
@@ -1562,6 +1595,29 @@ public <T> ApiResponse<T> invokeAPI(
     }
   }
 
+  private boolean shouldRetry(int retryCount, int statusCode, RetryConfig retryConfig) {
+    boolean statusToRetry = false;
+    if (statusCode == 429 || statusCode >= 500) {
+      statusToRetry = true;
+    }
+    return (retryConfig.maxRetries > retryCount && statusToRetry && retryConfig.isEnableRetry());
+  }
+
+  private int calculateRetryInterval(
+      Map<String, List<String>> responseHeaders, RetryConfig retryConfig, int retryCount) {
+    if (responseHeaders.get("x-ratelimit-reset") != null) {
+      List<String> rateLimitHeader = responseHeaders.get("x-ratelimit-reset");
+      return Integer.parseInt(rateLimitHeader.get(0));
+    } else {
+      int retryInterval =
+          (int) Math.pow(retry.backOffMultiplier, retryCount) * retryConfig.backOffBase;
+      if (getConnectTimeout() > 0) {
+        retryInterval = Math.min(retryInterval, getConnectTimeout());
+      }
+      return retryInterval;
+    }
+  }
+
   private Response sendRequest(
       String method, Invocation.Builder invocationBuilder, Entity<?> entity) {
     Response response;