REST API와 네트워크 오류에 대응하는 자바스크립트 재시도 전략

const axios = require("axios");

const fetchDataWithFixedRetry = async (url, retries, interval) => {
  for (let i = 0; i <= retries; i++) {
    try {
      const response = await axios.get(url);
      console.log(`Success: ${response.status}`);
      return response.data;
    } catch (error) {
      if (i < retries) {
        console.log(`Attempt ${i + 1} failed. Retrying in ${interval} ms...`);
        await new Promise((resolve) => setTimeout(resolve, interval));
      } else {
        console.log("All retries failed");
        throw error;
      }
    }
  }
};

const url = "https://sample.api.com/1";
fetchDataWithFixedRetry(url, 3, 5000).catch(console.error);

const axios = require("axios");

const fetchDataWithBackoffAndLimit = async (url, retries, delay) => {
  for (let i = 0; i <= retries; i++) {
    try {
      const response = await axios.get(url);
      console.log(`Success: ${response.status}`);
      return response.data;
    } catch (error) {
      if (i < retries) {
        const backoff = delay * Math.pow(2, i);
        console.log(`Attempt ${i + 1} failed. Retrying in ${backoff} ms...`);
        await new Promise((resolve) => setTimeout(resolve, backoff));
      } else {
        console.log("All retries failed");
        throw error;
      }
    }
  }
};

const url = "https://sample.api.com/1";
fetchDataWithBackoffAndLimit(url, 3, 1000).catch(console.error);

const axios = require("axios");

let attemptCounter = 0; // 실패 시뮬레이션 시도 횟수 추적

/**
 * 이 함수는 HTTP 요청에 대해 axios를 사용하는 선형 백오프 전략을 보여줍니다.
 * 초기 시도에서 네트워크 실패를 시뮬레이션한 다음 성공하여, 애플리케이션이 적절한 재시도 로직을 기반으로 일시적인 문제로부터 어떻게 회복할 수 있는지 보여줍니다.
 *
 * 선형 백오프 전략은 재시도 간의 지연 시간을 고정적으로 증가시켜 재시도 간격을 관리하는 균형 잡힌 접근 방식을 제공하며, 다음 시도 전에 시스템이 복구할 수 있는 시간을 제공합니다.
 *
 * 매개변수:
 * - url: 데이터를 가져올 URL
 * - retries: 재시도 허용 횟수
 * - delay: 첫 번째 재시도 전 초기 지연 시간
 * - increment: 재시도 후 지연 시간 증가량
 *
 * 실패 시, 이 함수는 지정된 지연 시간을 기다린 후 선형 백오프 계산을 기반으로 증가한 지연 시간으로 요청을 재시도 합니다.
 */
const fetchDataWithLinearBackoff = async (url, retries, delay, increment) => {
  try {
    attemptCounter++;
    if (attemptCounter <= 3) {
      throw new Error("Simulated network failure");
    }

    const response = await axios.get(url);
    console.log(`Success: ${response.status}`);
    return response.data;
  } catch (error) {
    console.log(
      `Attempt ${attemptCounter} failed with error: ${error.message}. Waiting ${delay} ms before retrying.`
    );
    if (retries > 0) {
      await new Promise((resolve) => setTimeout(resolve, delay));
      return fetchDataWithLinearBackoff(
        url,
        retries - 1,
        delay + increment,
        increment
      );
    } else {
      throw new Error("All retries failed");
    }
  }
};

const url = "https://sample.api.com/1";
fetchDataWithLinearBackoff(url, 5, 1000, 2000).catch(console.error);

/**
 * 결과물:
 * 시도 1 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 1000 밀리초를 기다립니다.
 * 시도 2 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 3000 밀리초를 기다립니다.
 * 시도 3 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 5000 밀리초를 기다립니다.
 * 성공: 200
 */

const axios = require("axios");

let attemptCounter = 0; // 시나리오 시뮬레이션을 위한 시도 횟수 추적 방법

/**
 * axios를 사용하여 HTTP 요청에 대한 고정 지연 재시도 전략을 구현하는 방법을 시도합니다.
 * 초기 시도에 대한 실패를 시뮬레이션하여 고정 지연 재시도가 시도 횟수에 상관없이 재시도 전에 미리 계산된 시간을 대기함으로써 일시적인 오류를 효과적으로 관리할 방법을 설명합니다.
 *
 * 고정 지연 방식은 재시도 간격을 일정하게 유지하여 시스템 복구 및 오류 해결을 다음 시도 전에 가능하게 하는 간단하고 예측 가능한 방법을 제공합니다. 이 전략은 복구 예상 시간이 일정한 상황에서 특히 유용합니다.
 *
 * 매개변수:
 * - url: HTTP GET 요청을 위한 엔드포인트 URL
 * - retries: 종료 전 재시도 횟수
 * - delay: 재시도 전 대기하는 고정 시간(밀리초)
 */
const fetchData = async (url, retries, delay) => {
  try {
    attemptCounter++;

    if (attemptCounter <= 3) {
      throw new Error("Simulated network failure");
    }

    const response = await axios.get(url);
    console.log(`Success: ${response.status}`);
    return response.data;
  } catch (error) {
    console.log(
      `Attempt ${attemptCounter} failed with error: ${error.message}. Waiting ${delay} ms before retrying.`
    );
    if (retries > 0) {
      await new Promise((resolve) => setTimeout(resolve, delay));
      return fetchData(url, retries - 1, delay);
    } else {
      throw new Error("All retries failed");
    }
  }
};

const url = "https://sample.api.com/1";
fetchData(url, 4, 1000).catch(console.error);

/**
 * 결과물:
 * 시도 1 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 1000 밀리초를 기다립니다.
 * 시도 2 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 1000 밀리초를 기다립니다.
 * 시도 3 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 1000 밀리초를 기다립니다.
 * 성공: 200
 */

const axios = require("axios");

let attemptCounter = 0; // 시뮬레이션을 위한 현재 시도 추적

/**
 * 주어진 인덱스에 대한 피보나치 수를 계산합니다. 피보나치 수열은 보통 0과 1의 시작으로 각각의 수가 앞의 두 수의 합이 되는 수열입니다.
 *
 * - index: 피보나치 수열의 위치
 */
const calculateFibonacciNumber = (index) => {
  if (index <= 1) return index;
  let previous = 0,
    current = 1,
    temp;
  for (let i = 2; i <= index; i++) {
    temp = previous + current;
    previous = current;
    current = temp;
  }
  return current;
};

/**
 * axios를 사용하여 HTTP GET 요청에 대한 피보나치 백오프 전략을 기반한 재시도를 수행합니다.
 * 처음 몇 번의 시도에서 네트워크 실패를 시뮬레이션하여, 피보나치 수열을 기반한 지연 시간이 증가하는 재시도 전략을 사용함으로써 애플리케이션이 어떻게 다시 정상 작동하게 되는지 보여줍니다.
 * - url: 요청 보낼 URL
 * - retries: 실패 전 허용된 재시도 횟수
 * - baseDelay: 피보나치 백오프 계산을 위한 기본 지연 시간(밀리초)
 */
const fetchData = async (url, retries, baseDelay) => {
  try {
    attemptCounter++;

    if (attemptCounter <= 2) {
      throw new Error("Simulated network failure");
    }

    const response = await axios.get(url);
    console.log(`Success: ${response.status}`);
    return response.data;
  } catch (error) {
    console.log(
      `Attempt ${attemptCounter} failed with error: ${error.message}. Waiting for the next attempt.`
    );
    if (retries > 0) {
      const delay = calculateFibonacciNumber(5 - retries + 1) * baseDelay;
      console.log(`Waiting ${delay} ms before retrying.`);
      await new Promise((resolve) => setTimeout(resolve, delay));
      return fetchData(url, retries - 1, baseDelay);
    } else {
      throw new Error(
        "All retries failed after " + attemptCounter + " attempts"
      );
    }
  }
};

const url = "https://sample.api.com/1";
fetchData(url, 5, 100).catch(console.error);

/**
 * 결과물:
 * 시도 1 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 100 밀리초를 기다립니다.
 * 시도 2 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 200 밀리초를 기다립니다.
 * 시도 3 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 300 밀리초를 기다립니다.
 * 시도 4 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 500 밀리초를 기다립니다.
 * 성공: 200
 */

const axios = require("axios");

let attemptCounter = 0; // 시도 횟수 추적 및 네트워크 오류 시뮬레이션.

/**
 * 무작위 지연을 포함한 재시도와 함께 axios를 사용하여 HTTP GET 요청을 수행합니다.
 * 네트워크 오류 시뮬레이션 전략은 특정 최소 범위와 최대 범위 사이의 임의 지연을 재시도하여 복구할 방법을 설명합니다.
 * 재시도 간격의 랜덤화는 부하 분산과 시스템 피크 압력 감소에 도움이 됩니다.
 *
 * - url: HTTP GET 요청을 위한 엔드포인트 URL
 * - retries: 종료 전 재시도 횟수
 * - minDelay: 재시도 전 최소 지연 시간(밀리초)
 * - maxDelay: 재시도 전 최대 지연 시간(밀리초)
 */
const fetchData = async (url, retries, minDelay, maxDelay) => {
  try {
    attemptCounter++;

    if (attemptCounter <= 2) {
      throw new Error("Simulated network failure");
    }

    const response = await axios.get(url);
    console.log(`Success: ${response.status}`);
    return response.data;
  } catch (error) {
    console.log(
      `Attempt ${attemptCounter} failed with error: ${error.message}.`
    );
    if (retries > 0) {
      const randomDelay = Math.random() * (maxDelay - minDelay) + minDelay; // 임의 지연 시간 계산
      console.log(`Waiting ${Math.round(randomDelay)} ms before retrying.`);
      await new Promise((resolve) =>
        setTimeout(resolve, Math.round(randomDelay))
      );
      return fetchData(url, retries - 1, minDelay, maxDelay);
    } else {
      throw new Error(`All retries failed after ${attemptCounter} attempts`);
    }
  }
};

const url = "https://sample.api.com/1";
fetchData(url, 3, 500, 1500).catch(console.error);

/**
 * 결과물:
 * 시도 1 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 1487 밀리초를 기다립니다.
 * 시도 2 실패 오류: 시뮬레이션한 네트워크 실패. 재시도 전 777 밀리초를 기다립니다.
 * 성공: 200
 */

const axios = require("axios");

let attemptCounter = 0; // 네트워크 실패를 시뮬레이션하기 위해 현재 시도 횟수 추적.

/**
 * 실패 시 즉각적인 재시도 전략을 사용하여 axios를 사용한 HTTP GET 요청을 실행합니다.
 * 이 접근법은 초반에 몇 번의 시도를 통해 네트워크 실패를 시뮬레이션하여, 빠르게 해결할 수 있는 일시적인 문제를 어떻게 애플리케이션이 지연 없이 즉시 재시도하여 적용되는지 설명합니다.
 *
 * 즉각적인 재시도는 오류가 일시적일 가능성이 높고 지연을 적용하지 않고 해결될 수 있는 상황에서 사용됩니다. 이는 네트워크 안정성이 변동하는 환경에서 성공적인 요청 가능성에서 효과적입니다.
 *
 * - url: HTTP GET 요청을 위한 엔드포인트 URL
 * - retries: 종료 전 재시도 횟수
 */
const fetchData = async (url, retries) => {
  try {
    attemptCounter++;

    if (attemptCounter <= 3) {
      throw new Error("Simulated network failure");
    }

    const response = await axios.get(url);
    console.log(`Success: ${response.status}`);
    return response.data;
  } catch (error) {
    console.log(
      `Attempt ${attemptCounter} failed with error: ${error.message}.`
    );
    if (retries > 0) {
      console.log("Retrying immediately.");
      return fetchData(url, retries - 1);
    } else {
      throw new Error(`All retries failed after ${attemptCounter} attempts`);
    }
  }
};

const url = "https://sample.api.com/1";
fetchData(url, 5).catch(console.error);

/**
 * 결과물:
 * 시도 1 실패 오류: 시뮬레이션한 네트워크 실패. 즉시 재시도.
 * 시도 2 실패 오류: 시뮬레이션한 네트워크 실패. 즉시 재시도.
 * 시도 3 실패 오류: 시뮬레이션한 네트워크 실패. 즉시 재시도.
 * 성공: 200
 */

npm install axios axios-retry

or

yarn add axios axios-retry

import axios from "axios";
import axiosRetry from "axios-retry";

// 자동 재시도 요청을 위한 axios-retry 구성
axiosRetry(axios, {
  retries: 3, // 재시도 횟수
  retryDelay: axiosRetry.exponentialDelay, // 재시도 사이에 지수 백오프 지연 사용
});

// 실패 시 재시도되는 axios 요청
axios
  .get("https://sample.api.com/1")
  .then((response) => console.log(response.data))
  .catch((error) => console.error(error));

npm install retry

or

yarn add retry

const retry = require("retry");
const axios = require("axios"); // axios가 HTTP 요청에 사용된다고 가정해봅시다.

async function fetchData(url) {
  const operation = retry.operation({
    retries: 3, // 최대 재시도 횟수
    factor: 2, // 지연에 대한 지수 계수
    minTimeout: 1000, // 첫 번째 재시도를 시작하기 전의 시간(밀리초)
    maxTimeout: 2000, // 두 번째 재시도 사이의 최대 시간(밀리초)
  });

  operation.attempt(async (currentAttempt) => {
    try {
      const response = await axios.get(url);
      console.log("Data:", response.data);
    } catch (error) {
      console.log(`Attempt ${currentAttempt} failed: ${error.message}`);
      if (operation.retry(error)) {
        console.log(`Retrying...`);
        return;
      }
      console.error("Request failed after retries:", error.message);
    }
  });
}

fetchData("https://sample.api.com/1");