[Draft]: Added Exponential Retry Mechanism with Idempotency Headers

src/main/java/co/novu/common/base/NovuConfig.java

@@ -11,6 +11,13 @@ public NovuConfig(String apiKey) {
         this.apiKey = apiKey;
     }
 
-    private String apiKey;
+	private String apiKey;
     private String baseUrl = "https://api.novu.co/v1/";
+
+    private int maxRetries = 3;
+    private int minRetryDelayMillis = 500; // 500 milli seconds
+    private int maxRetryDelayMillis = 60000; // 60 seconds
+    private int initialRetryDelayMillis = 1000; // 1 second
+    private boolean enableRetry = true; // To enable/disable retry logic
+    private boolean enableIdempotencyKey = true; // To enable/disable idempotency key
 }

src/main/java/co/novu/common/rest/IdempotencyKeyInterceptor.java

@@ -0,0 +1,29 @@
+package co.novu.common.rest;
+
+import java.io.IOException;
+import java.util.UUID;
+
+import okhttp3.Interceptor;
+import okhttp3.Request;
+import okhttp3.Response;
+
+public class IdempotencyKeyInterceptor implements Interceptor{
+
+	@Override
+	public Response intercept(Chain chain) throws IOException {
+		Request request = chain.request();
+        Response response = null;
+
+        Request requestWithIdempotencyKey = request.newBuilder()
+        		.header("Idempotency-Key", generateIdempotencyKey())
+                .build();
+        response = chain.proceed(requestWithIdempotencyKey);
+        return response;
+	}
+
+	private String generateIdempotencyKey() {
+        UUID uuid = UUID. randomUUID();
+        return uuid.toString();
+    }
+
+}

src/main/java/co/novu/common/rest/RestHandler.java

@@ -1,9 +1,13 @@
 package co.novu.common.rest;
 
-import co.novu.common.base.NovuConfig;
-import co.novu.common.contracts.IRequest;
+import java.io.IOException;
+import java.util.Map;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+
+import co.novu.common.base.NovuConfig;
+import co.novu.common.contracts.IRequest;
 import lombok.RequiredArgsConstructor;
 import okhttp3.OkHttpClient;
 import okhttp3.Request;
@@ -12,9 +16,6 @@
 import retrofit2.Retrofit;
 import retrofit2.converter.gson.GsonConverterFactory;
 
-import java.io.IOException;
-import java.util.Map;
-
 @RequiredArgsConstructor
 public class RestHandler {
 
@@ -35,6 +36,14 @@ public Retrofit buildRetrofit() {
                             .build();
                     return chain.proceed(request);
                 }).addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BASIC));
+
+        if(novuConfig.isEnableRetry()) {
+        	clientBuilder.addInterceptor(new RetryInterceptor(novuConfig.getMaxRetries(), novuConfig.getMinRetryDelayMillis() , novuConfig.getMaxRetryDelayMillis() , novuConfig.getInitialRetryDelayMillis()));
+        }
+
+        if(novuConfig.isEnableIdempotencyKey()) {
+        	clientBuilder.addInterceptor(new IdempotencyKeyInterceptor());
+        }
 
         Gson gson = new GsonBuilder()
                 .setLenient()

src/main/java/co/novu/common/rest/RetryInterceptor.java

@@ -0,0 +1,62 @@
+package co.novu.common.rest;
+
+import java.io.IOException;
+
+import okhttp3.Interceptor;
+import okhttp3.Request;
+import okhttp3.Response;
+
+public class RetryInterceptor implements Interceptor{
+
+	private final int maxRetries;
+	private final int minRetryDelayMillis;
+	private final int maxRetryDelayMillis;
+    private final int initialRetryDelayMillis;
+
+    public RetryInterceptor(int maxRetries, int minRetryDelayMillis, int maxRetryDelayMillis, int initialRetryDelayMillis) {
+        this.maxRetries = maxRetries;
+        this.minRetryDelayMillis = minRetryDelayMillis;
+        this.maxRetryDelayMillis = maxRetryDelayMillis;
+        this.initialRetryDelayMillis = initialRetryDelayMillis;
+    }
+
+	@Override
+	public Response intercept(Chain chain) throws IOException {
+		Request request = chain.request();
+        Response response = null;
+        IOException lastException = null;
+
+        for (int retry = 0; retry < maxRetries; retry++) {
+            try {
+                response = chain.proceed(request);
+                if (response.isSuccessful()) {
+                    return response; // Request was successful, no need to retry
+                }
+            } catch (IOException e) {
+                lastException = e;
+            }
+
+            try {
+            	int retryDelay;
+                if (retry == 0) {
+                    retryDelay = initialRetryDelayMillis;
+                } else {
+                    retryDelay = (int) (initialRetryDelayMillis * Math.pow(2, retry - 1));
+                }
+                retryDelay = Math.max(retryDelay, minRetryDelayMillis);
+                retryDelay = Math.min(retryDelay, maxRetryDelayMillis);
+                Thread.sleep(retryDelay);
+            } catch (InterruptedException ignored) {
+                Thread.currentThread().interrupt();
+            }
+        }
+
+        // If all retries failed, throw the last exception
+        if (lastException != null) {
+            throw lastException;
+        }
+
+        return response;
+    }
+
+}