Implement Repeated API call until success with exponential wait time - Retry API Call

Re-Try Sometimes, we need to make an API call until getting the success response or retry up to n times for some reason. Suppose we have a very important API call that needs to be a success and they are independent API call and the dependent API call takes some time to process operation-x, in between someone hit the API call to get the result of operation-x, but operation-x is not yet finished by 3rd API, at this time it will send a response with ERROR and after some time when operation-x will be finished then the calling API will be a success. To handle this situation we need to write some retry mechanisms.

Didn't understand?

Let me give you an example. Please have a look on below image.

Implement Repeated API call until success with exponential wait time - Retry API Call

In the above image, you can see, there are so many things, let me describe you.
There is a Front End and Back End. Front End raised an API call to Back End. Now Back End will have some logic to do retry an API call upto 5 times and with exponential wait time.

Exponential Wait Time:
It means the API call will wait 2 second and if get failed, then the next API call will wait 4 second, if get failed, then the next API call will wait for 8 seconds and so on.

So, the Back End have a method called retryRequest() and this retryRequest() will call a 3rd party API myAPI().
Now, retryRequest() call myAPI() 1st time and if this get failed, then retryRequest() will call myAPI() 2nd time after 2 seconds, and again the 3rd party API myAPI() will be failed.

Now, retryRequest() call myAPI() 3rd time after 4 seconds, and if this get failed, then retryRequest() will call myAPI() 4th time after 8 seconds and so on. But retry will happened upto 5 times.

If we get the success before or on 5th retry then the Back End will send the success response to the Front End.

And if the in the 5th retry the API myAPI() still getting failed then the Back End will send the response to Front End with error details.

Now it's time to Implement Repeated API call until success with exponential wait time.

Write the codes:

First thing first, Let's create a dummy callback function myAPI(), it will give errir 3 times and 4th time it will be success with data.

Implement 3rd party API/callback:

File: retry.js:

                            var count = 1;
                            const myAPI = async () => {
                            if (count > 3) {
                                return Promise.resolve({ error_code: null, data: true });
                            }
                            count++;
                            throw ({ error_code: 'SOME_ERROR_CODE', data: null });
                            }
                    
                            myAPI().then((data) => console.log('API CALL 1 :', data)).catch((err)=>console.log('ERROR:',err));
                    
                            myAPI().then((data) => console.log('API CALL 2 :', data)).catch((err)=>console.log('ERROR:',err));
                    
                            myAPI().then((data) => console.log('API CALL 3 :', data)).catch((err)=>console.log('ERROR:',err));
                    
                            myAPI().then((data) => console.log('API CALL 4 :', data)).catch((err)=>console.log('ERROR:',err));
                    
                    

Run the above codes:

Now let's run the above codes using below command and see the output.

node retry.js

Output:

Implement Repeated API call until success with exponential wait time - Retry API Call

Describe possible error codes:

                            const RETRYABLE_ERROR_CODES = [
                            'SOME_ERROR_CODE',
                            'SERVICE_UNAVAILABLE',
                            'ECONNRESET',
                            'SERVER_ERROR',
                        ];
                    

The above error codes will be used in the retry logic. If any of the above error codes will come in response as error then the retry function would be called. You can change this logic as per your requirements, You can add more logic or can update this logic as per response.

Check the retry error in depth:

                        const isRetryableError = error =>
                        (error.code && RETRYABLE_ERROR_CODES.includes(error.code)) ||
                        (error.error_code && RETRYABLE_ERROR_CODES.includes(error.error_code)) ||
                        (error.lastError && RETRYABLE_ERROR_CODES.includes(error.lastError.code)) ||
                        (error.lastError &&
                            RETRYABLE_ERROR_CODES.includes(error.lastError.error_code)) ||
                        (error.message && error.message.includes('Service Unavailable')) ||
                        (typeof error === 'string' && error.includes('Service Unavailable'));
                    

In the above codes, we have defined all the possible error response structure that we can get from the 3rd party APIs. You can change this logic as per your requirements, You can add more logic or can update this logic as per response.

Implement Exponential Wait Time:

                        const waitingTimeInMs = retryCount => {
                            const maxExponentialCount = 32;
                            const exponentialCount = 2 ** retryCount;
                            return (Math.min(exponentialCount, maxExponentialCount)) * 1000
                    };
                    

In the above codes, we have implemented Exponential Wait Time. We have also checked that what would be the maximum wait time that the "Repeated API call until success with exponential wait time" logic will wait. So, the wait time would be minimum from maxExponentialCount and exponentialCount. Here the maximum wait time is 32 seconds.

Implement Retry Logic:

                            const retryRequest = (clientRequest, maxRetries = 4) => {
                                const retryFn = async retryCount => {
                                    try {
                                        if (retryCount > 0) {
                                            const timeToWait = waitingTimeInMs(retryCount);
                                            console.log('API will be called after:', timeToWait)
                                            await waitFor(timeToWait);
                                        }
                                        console.log("\nretryCount :", retryCount);
                                        return await clientRequest();
                                    } catch (err) {
                                        console.log("Error Received :", err);
                                        if (isRetryableError(err) && retryCount < maxRetries) {
                                            return retryFn(retryCount + 1);
                                        } else {
                                            throw err;
                                        }
                                    }
                                };
                                
                                return retryFn(0);
                            };
                    

In the above codes, we have implemented the "Repeated API call until success with exponential wait time". We have a retryFn() that will be call in loop untill the 3rd party get the success or the upto limit is ehausted. Also the retryFn() will wait for the given wait time to call the next round of API call.

How to call:

                            /** Calling Retry */
                            retryRequest(async () => myAPI())
                            .then((data) => console.log('retryRequest response :', data));
                    

We can call the retryRequest() with given callback function. This given callback function will be called as 3rd party API and will be called again and again and will be repeated API call until success with exponential wait time.

Complete Codes:

File: retry.js:

                    
                                var count = 1;
                                const myAPI = async () => {
                                if (count > 3) {
                                    return Promise.resolve({ error_code: null, data: true });
                                }
                                count++;
                                throw ({ error_code: 'SOME_ERROR_CODE', data: null });
                                }
                                
                                // myAPI().then((data) => console.log('API CALL 1 :', data)).catch((err)=>console.log('ERROR:',err));
                                
                                // myAPI().then((data) => console.log('API CALL 2 :', data)).catch((err)=>console.log('ERROR:',err));
                                
                                // myAPI().then((data) => console.log('API CALL 3 :', data)).catch((err)=>console.log('ERROR:',err));
                                
                                // myAPI().then((data) => console.log('API CALL 4 :', data)).catch((err)=>console.log('ERROR:',err));
                                
                                
                                const RETRYABLE_ERROR_CODES = [
                                    'SOME_ERROR_CODE',
                                    'SERVICE_UNAVAILABLE',
                                    'ECONNRESET',
                                    'SERVER_ERROR',
                                ];
                                
                                const isRetryableError = error =>
                                        (error.code && RETRYABLE_ERROR_CODES.includes(error.code)) ||
                                        (error.error_code && RETRYABLE_ERROR_CODES.includes(error.error_code)) ||
                                        (error.lastError && RETRYABLE_ERROR_CODES.includes(error.lastError.code)) ||
                                        (error.lastError &&
                                            RETRYABLE_ERROR_CODES.includes(error.lastError.error_code)) ||
                                        (error.message && error.message.includes('Service Unavailable')) ||
                                        (typeof error === 'string' && error.includes('Service Unavailable'));
                                
                                const waitFor = milliseconds =>
                                     new Promise(resolve => setTimeout(resolve, milliseconds));
                                
                                const waitingTimeInMs = retryCount => {
                                        const maxExponentialCount = 32;
                                        const exponentialCount = 2 ** retryCount;
                                        return (Math.min(exponentialCount, maxExponentialCount)) * 1000
                                };
                                
                                const retryRequest = (clientRequest, maxRetries = 4) => {
                                    const retryFn = async retryCount => {
                                        try {
                                            if (retryCount > 0) {
                                                const timeToWait = waitingTimeInMs(retryCount);
                                                console.log('API will be called after:', timeToWait)
                                                await waitFor(timeToWait);
                                            }
                                            console.log("\nretryCount :", retryCount);
                                            return await clientRequest();
                                        } catch (err) {
                                            console.log("Error Received :", err);
                                            if (isRetryableError(err) && retryCount < maxRetries) {
                                                return retryFn(retryCount + 1);
                                            } else {
                                                throw err;
                                            }
                                        }
                                    };
                                    
                                    return retryFn(0);
                                };
                                
                                
                                /** Calling Retry */
                                retryRequest(async () => myAPI())
                                .then((data) => console.log('retryRequest response :', data));
                    
                    

Run the above codes:

Now let's run the above codes using below command and see the output.

node retry.js

Output:

Implement Repeated API call until success with exponential wait time - Retry API Call

---

Conclusion:

In this article, we have implemented the Repeated API call until success with exponential wait time means implemented Retry API Calls. We have written our logic with exponential wait time and upto n retry times. Also we have fixed the wait time upto a level. So, this would be a greate code to implement the repeated API call until success with exponential wait time.