Documentation
¶
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type ExponentialBackoff ¶
type ExponentialBackoff struct { // WaitTime is the time duration used to calculate exponential backoff wait times. // Initially, it serves as the starting wait duration, and then it evolves. // // Default: 1/2 Second WaitTime time.Duration // Timeout is the time within the Strategy is attempting further retries. // If the total waited time is greater than the Timeout, ExponentialBackoff will stop further attempts. // When Timeout is given, but MaxRetries is not, ExponentialBackoff will continue to retry until // // Default: ignored Timeout time.Duration // MaxRetries is the amount of retry which is allowed before giving up the application. // // Default: 5 if Timeout is not set. MaxRetries int }
ExponentialBackoff will answer if retry can be made. It waits as well the amount of time based on the failure count. The waiting time before returning is doubled for each failed attempts This ensures that the system gets progressively more time to recover from any issues.
Example ¶
package main import ( "context" "go.llib.dev/frameless/pkg/retry" ) func main() { ctx := context.Background() rs := retry.ExponentialBackoff{} for i := 0; rs.ShouldTry(ctx, i); i++ { // do an action // return on success } // return failure }
func (ExponentialBackoff) ShouldTry ¶
func (rs ExponentialBackoff) ShouldTry(ctx context.Context, failureCount FailureCount) bool
type FailureCount ¶ added in v0.176.0
type FailureCount = int
type FixedDelay ¶ added in v0.254.0
type FixedDelay struct { // WaitTime is the time duration used to calculate exponential backoff wait times. // Initially, it serves as the starting wait duration, and then it evolves. // // Default: 1/2 Second WaitTime time.Duration // Timeout is the time within the Strategy is attempting further retries. // If the total waited time is greater than the Timeout, ExponentialBackoff will stop further attempts. // When Timeout is given, but MaxRetries is not, ExponentialBackoff will continue to retry until // // Default: ignored Timeout time.Duration // MaxRetries is the amount of retry which is allowed before giving up the application. // // Default: 5 if Timeout is not set. MaxRetries int }
Example ¶
package main import ( "context" "time" "go.llib.dev/frameless/pkg/retry" ) func main() { ctx := context.Background() rs := retry.FixedDelay{ WaitTime: 10 * time.Second, Timeout: 5 * time.Minute, } for i := 0; rs.ShouldTry(ctx, i); i++ { // do an action // return/break on success } // return failure }
func (FixedDelay) ShouldTry ¶ added in v0.254.0
func (rs FixedDelay) ShouldTry(ctx context.Context, failureCount FailureCount) bool
type Jitter ¶
type Jitter struct { // MaxRetries is the amount of retry that is allowed before giving up the application. // // Default: 5 MaxRetries int // MaxWaitTime is the duration the Jitter will maximum wait between two retries. // // Default: 5 Second MaxWaitTime time.Duration }
Jitter is a random variation added to the backoff time. This helps to distribute the retry attempts evenly over time, reducing the risk of overwhelming the system and avoiding synchronization between multiple clients that might be retrying simultaneously.
Example ¶
package main import ( "context" "go.llib.dev/frameless/pkg/retry" ) func main() { ctx := context.Background() rs := retry.Jitter{} for i := 0; rs.ShouldTry(ctx, i); i++ { // do an action // return on success } // return failure }
type Strategy ¶
type Strategy[U StrategyUnit] interface { // ShouldTry will tell if retry should be attempted after a given number of failed attempts. ShouldTry(ctx context.Context, u U) bool }
type StrategyUnit ¶ added in v0.176.0
type StrategyUnit interface{ FailureCount | StartedAt }
type Waiter ¶ added in v0.176.0
type Waiter struct { // Timeout refers to the maximum duration we can wait // before a retry attempt is deemed unreasonable. // // Default: 30 seconds Timeout time.Duration }
func (Waiter) ShouldTry ¶ added in v0.176.0
Example ¶
package main import ( "context" "time" "go.llib.dev/frameless/pkg/retry" ) func main() { var ( ctx = context.Background() rs = retry.Waiter{Timeout: time.Minute} now = time.Now() ) for rs.ShouldTry(ctx, now) { // do an action // return on success } // return failure }
Click to show internal directories.
Click to hide internal directories.