feat: add exponential backoff retry strategy

Introduce a retry policy with exponential backoff and jitter for extractor and loader errors, with configurable max attempts and delay caps.

internal/app/custom_errors/extractor.error.go

@@ -5,12 +5,13 @@ import (
 	"fmt"
 	"sync"
 
+	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
 	"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
 	"github.com/google/uuid"
 )
 
 type ExtractorError struct {
-	Batch     models.Partition
+	Partition models.Partition
 	LastId    int64
 	HasLastId bool
 	Msg       string
@@ -22,11 +23,11 @@ func (e *ExtractorError) Error() string {
 
 func ExtractorErrorHandler(
 	ctx context.Context,
-	maxRetryAttempts int,
+	retryConfig config.RetryConfig,
 	chErrorsIn <-chan ExtractorError,
-	chBatchesOut chan<- models.Partition,
+	chPartitionsOut chan<- models.Partition,
 	chJobErrorsOut chan<- JobError,
-	wgActiveBatches *sync.WaitGroup,
+	wgActivePartitions *sync.WaitGroup,
 ) {
 	for {
 		if ctx.Err() != nil {
@@ -42,10 +43,11 @@ func ExtractorErrorHandler(
 				return
 			}
 
-			if err.Batch.RetryCounter >= maxRetryAttempts {
+			if err.Partition.RetryCounter >= retryConfig.Attempts {
+				wgActivePartitions.Done()
 				jobError := JobError{
 					ShouldCancelJob: false,
-					Msg:             fmt.Sprintf("batch %v reached max retries (%d)", err.Batch.Id, maxRetryAttempts),
+					Msg:             fmt.Sprintf("Partition %v reached max retries (%d)", err.Partition.Id, retryConfig.Attempts),
 					Prev:            &err,
 				}
 
@@ -55,25 +57,45 @@ func ExtractorErrorHandler(
 					return
 				}
 
-				wgActiveBatches.Done()
 				continue
+			} else {
+				jobError := JobError{
+					ShouldCancelJob: false,
+					Msg:             fmt.Sprintf("Temporal error in partition %v (retries: %d)", err.Partition.Id, err.Partition.RetryCounter),
+					Prev:            &err,
+				}
+
+				select {
+				case chJobErrorsOut <- jobError:
+				case <-ctx.Done():
+					return
+				}
 			}
 
-			newBatch := err.Batch
-			newBatch.RetryCounter++
+			newPartition := err.Partition
+			newPartition.RetryCounter++
+
+			delay := computeBackoffDelay(
+				newPartition.RetryCounter,
+				retryConfig.BaseDelayMs,
+				retryConfig.MaxDelayMs,
+				retryConfig.MaxJitterMs,
+			)
 
 			if err.HasLastId {
-				newBatch.ParentId = err.Batch.Id
-				newBatch.Id = uuid.New()
-				newBatch.LowerLimit = err.LastId
-				newBatch.IsLowerLimitInclusive = false
+				newPartition.ParentId = err.Partition.Id
+				newPartition.Id = uuid.New()
+				newPartition.LowerLimit = err.LastId
+				newPartition.IsLowerLimitInclusive = false
 			}
 
-			select {
-			case chBatchesOut <- newBatch:
-			case <-ctx.Done():
-				return
-			}
+			requeueWithBackoff(ctx, delay, func() {
+				select {
+				case chPartitionsOut <- newPartition:
+				case <-ctx.Done():
+					return
+				}
+			})
 		}
 	}
 }