implemented http request auto retry feature

internal/infrastructure/service/FetchDriversByRace.go

@@ -16,7 +16,7 @@ type Driver = domain_model.Driver
 func FetchDriversByRace(raceId int) ([]Driver, error) {
 
 	targetUrl := "https://api.openf1.org/v1/drivers?session_key=" + strconv.Itoa(raceId)
-	body, err := helper.HttpGet(targetUrl, true)
+	body, err := helper.HttpGet(targetUrl, &helper.HttpGetExtraArgs{UseCache: true, Retry: true})
 	if err != nil {
 		return nil, err
 	}

internal/infrastructure/service/FetchPodiumByRace.go

@@ -21,7 +21,7 @@ type Position struct {
 func FetchPodiumByRace(raceId int, drivers []domain_model.Driver) ([3]Podium, error) {
 
 	targetUrl := "https://api.openf1.org/v1/position?position<=3&session_key=" + strconv.Itoa(raceId)
-	body, err := helper.HttpGet(targetUrl, true)
+	body, err := helper.HttpGet(targetUrl, &helper.HttpGetExtraArgs{UseCache: true, Retry: true})
 	if err != nil {
 		return [3]Podium{}, err
 	}

internal/infrastructure/service/FetchRacesByYear.go

@@ -17,7 +17,7 @@ type Race = domain_model.Race
 func FetchRacesByYear(year int) ([]Race, error) {
 
 	targetUrl := "https://api.openf1.org/v1/sessions?year=" + strconv.Itoa(year) + "&session_type=Race"
-	body, err := helper.HttpGet(targetUrl, true)
+	body, err := helper.HttpGet(targetUrl, &helper.HttpGetExtraArgs{UseCache: true, Retry: true})
 	if err != nil {
 		return nil, err
 	}

internal/infrastructure/service/helper/HttpGet.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math/rand"
 	"net/http"
 	"sync"
 	"time"
@@ -19,14 +20,27 @@ type cacheValue struct {
 var reqCache = make(map[string]cacheValue)
 var rwMutex sync.RWMutex
 
-func HttpGet(targetUrl string, useCache bool) ([]byte, error) {
+type HttpGetExtraArgs struct {
+	UseCache   bool
+	Retry      bool
+	RetryCount int
+}
+
+const MAX_RETRIES = 2
+
+func HttpGet(targetUrl string, args *HttpGetExtraArgs) ([]byte, error) {
+
+	if args.RetryCount > 0 {
+		delay := time.Duration(args.RetryCount*2500 + rand.Intn(1000))
+		time.Sleep(delay * time.Millisecond)
+	}
 
 	rwMutex.RLock()
 	cachedValue, isCached := reqCache[targetUrl]
 	rwMutex.RUnlock()
 
 	now := time.Now().Unix()
-	useCachedValue := useCache && isCached && now <= cachedValue.validUntil
+	useCachedValue := args.UseCache && isCached && now <= cachedValue.validUntil
 
 	if useCachedValue {
 		return cachedValue.value, nil
@@ -35,6 +49,13 @@ func HttpGet(targetUrl string, useCache bool) ([]byte, error) {
 	// Fetch data
 	resp, err := http.Get(targetUrl)
 	if err != nil || resp.StatusCode < 200 || resp.StatusCode >= 300 {
+
+		if args.Retry && args.RetryCount < MAX_RETRIES {
+			log.Debug().Msg("Request error. Retrying request to " + targetUrl)
+			args.RetryCount++
+			return HttpGet(targetUrl, args)
+		}
+
 		errorMsg := fmt.Sprintf("Request error: %v at %v", err, targetUrl)
 		log.Error().Msg(errorMsg)
 
@@ -46,22 +67,27 @@ func HttpGet(targetUrl string, useCache bool) ([]byte, error) {
 	// Extract body
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
+		if args.Retry && args.RetryCount < MAX_RETRIES {
+			log.Debug().Msg("Error reading response body. Retrying request to " + targetUrl)
+			args.RetryCount++
+			return HttpGet(targetUrl, args)
+		}
+
 		errorMsg := fmt.Sprintf("Error reading response body: %v", err)
 		log.Error().Msg(errorMsg)
 
 		return nil, errors.New(errorMsg)
 	}
 
-	if useCache {
-		tenMinuteAfter := time.Now().Add(10 * time.Minute).Unix()
+	if args.UseCache {
+		oneHour := time.Now().Add(60 * time.Minute).Unix()
 
 		rwMutex.Lock()
 		reqCache[targetUrl] = cacheValue{
-			validUntil: tenMinuteAfter,
+			validUntil: oneHour,
 			value:      body,
 		}
 		rwMutex.Unlock()
-
 	}
 
 	return body, nil