README
¶
Exponential Backoff 
This is a Go port of the exponential backoff algorithm from Google's HTTP Client Library for Java.
Exponential backoff is an algorithm that uses feedback to multiplicatively decrease the rate of some process, in order to gradually find an acceptable rate. The retries exponentially increase and stop increasing when a certain threshold is met.
Usage
Import path is github.com/cenkalti/backoff/v5. Please note the version part at the end.
For most cases, use Retry function. See example_test.go for an example.
If you have specific needs, copy Retry function (from retry.go) into your code and modify it as needed.
Contributing
- I would like to keep this library as small as possible.
- Please don't send a PR without opening an issue and discussing it first.
- If proposed change is not a common use case, I will probably not accept it.
Documentation
¶
Overview ¶
Package backoff implements backoff algorithms for retrying operations.
Use Retry function for retrying operations that may fail. If Retry does not meet your needs, copy/paste the function into your project and modify as you wish.
There is also Ticker type similar to time.Ticker. You can use it if you need to work with channels.
See Examples section below for usage examples.
Index ¶
- Constants
- func Permanent(err error) error
- func Retry[T any](ctx context.Context, operation Operation[T], opts ...RetryOption) (T, error)
- func RetryAfter(seconds int) error
- type BackOff
- type ConstantBackOff
- type ExponentialBackOff
- type Notify
- type Operation
- type PermanentError
- type RetryAfterError
- type RetryOption
- type StopBackOff
- type Ticker
- type ZeroBackOff
Examples ¶
Constants ¶
const ( DefaultInitialInterval = 500 * time.Millisecond DefaultRandomizationFactor = 0.5 DefaultMultiplier = 1.5 DefaultMaxInterval = 60 * time.Second )
Default values for ExponentialBackOff.
const DefaultMaxElapsedTime = 15 * time.Minute
DefaultMaxElapsedTime sets a default limit for the total retry duration.
const Stop time.Duration = -1
Stop indicates that no more retries should be made for use in NextBackOff().
Variables ¶
This section is empty.
Functions ¶
func Retry ¶
Retry attempts the operation until success, a permanent error, or backoff completion. It ensures the operation is executed at least once.
Returns the operation result or error if retries are exhausted or context is cancelled.
Example ¶
// Define an operation function that returns a value and an error.
// The value can be any type.
// We'll pass this operation to Retry function.
operation := func() (string, error) {
// An example request that may fail.
resp, err := http.Get("http://httpbin.org/get")
if err != nil {
return "", err
}
defer resp.Body.Close()
// In case on non-retriable error, return Permanent error to stop retrying.
// For this HTTP example, client errors are non-retriable.
if resp.StatusCode == 400 {
return "", backoff.Permanent(errors.New("bad request"))
}
// If we are being rate limited, return a RetryAfter to specify how long to wait.
// This will also reset the backoff policy.
if resp.StatusCode == 429 {
seconds, err := strconv.ParseInt(resp.Header.Get("Retry-After"), 10, 64)
if err == nil {
return "", backoff.RetryAfter(int(seconds))
}
}
// Return successful response.
return "hello", nil
}
result, err := backoff.Retry(context.TODO(), operation, backoff.WithBackOff(backoff.NewExponentialBackOff()))
if err != nil {
fmt.Println("Error:", err)
return
}
// Operation is successful.
fmt.Println(result)
Output: hello
func RetryAfter ¶
RetryAfter returns a RetryAfter error that specifies how long to wait before retrying.
Types ¶
type BackOff ¶
type BackOff interface {
// NextBackOff returns the duration to wait before retrying the operation,
// backoff.Stop to indicate that no more retries should be made.
//
// Example usage:
//
// duration := backoff.NextBackOff()
// if duration == backoff.Stop {
// // Do not retry operation.
// } else {
// // Sleep for duration and retry operation.
// }
//
NextBackOff() time.Duration
// Reset to initial state.
Reset()
}
BackOff is a backoff policy for retrying an operation.
type ConstantBackOff ¶
ConstantBackOff is a backoff policy that always returns the same backoff delay. This is in contrast to an exponential backoff policy, which returns a delay that grows longer as you call NextBackOff() over and over again.
func NewConstantBackOff ¶
func NewConstantBackOff(d time.Duration) *ConstantBackOff
func (*ConstantBackOff) NextBackOff ¶
func (b *ConstantBackOff) NextBackOff() time.Duration
func (*ConstantBackOff) Reset ¶
func (b *ConstantBackOff) Reset()
type ExponentialBackOff ¶
type ExponentialBackOff struct {
InitialInterval time.Duration
RandomizationFactor float64
Multiplier float64
MaxInterval time.Duration
// contains filtered or unexported fields
}
ExponentialBackOff is a backoff implementation that increases the backoff period for each retry attempt using a randomization function that grows exponentially.
NextBackOff() is calculated using the following formula:
randomized interval =
RetryInterval * (random value in range [1 - RandomizationFactor, 1 + RandomizationFactor])
In other words NextBackOff() will range between the randomization factor percentage below and above the retry interval.
For example, given the following parameters:
RetryInterval = 2 RandomizationFactor = 0.5 Multiplier = 2
the actual backoff period used in the next retry attempt will range between 1 and 3 seconds, multiplied by the exponential, that is, between 2 and 6 seconds.
Note: MaxInterval caps the RetryInterval and not the randomized interval.
If the time elapsed since an ExponentialBackOff instance is created goes past the MaxElapsedTime, then the method NextBackOff() starts returning backoff.Stop.
The elapsed time can be reset by calling Reset().
Example: Given the following default arguments, for 10 tries the sequence will be, and assuming we go over the MaxElapsedTime on the 10th try:
Request # RetryInterval (seconds) Randomized Interval (seconds) 1 0.5 [0.25, 0.75] 2 0.75 [0.375, 1.125] 3 1.125 [0.562, 1.687] 4 1.687 [0.8435, 2.53] 5 2.53 [1.265, 3.795] 6 3.795 [1.897, 5.692] 7 5.692 [2.846, 8.538] 8 8.538 [4.269, 12.807] 9 12.807 [6.403, 19.210] 10 19.210 backoff.Stop
Note: Implementation is not thread-safe.
func NewExponentialBackOff ¶
func NewExponentialBackOff() *ExponentialBackOff
NewExponentialBackOff creates an instance of ExponentialBackOff using default values.
func (*ExponentialBackOff) NextBackOff ¶
func (b *ExponentialBackOff) NextBackOff() time.Duration
NextBackOff calculates the next backoff interval using the formula:
Randomized interval = RetryInterval * (1 ± RandomizationFactor)
func (*ExponentialBackOff) Reset ¶
func (b *ExponentialBackOff) Reset()
Reset the interval back to the initial retry interval and restarts the timer. Reset must be called before using b.
type PermanentError ¶
type PermanentError struct {
Err error
}
PermanentError signals that the operation should not be retried.
func (*PermanentError) Error ¶
func (e *PermanentError) Error() string
Error returns a string representation of the Permanent error.
func (*PermanentError) Unwrap ¶
func (e *PermanentError) Unwrap() error
Unwrap returns the wrapped error.
type RetryAfterError ¶
RetryAfterError signals that the operation should be retried after the given duration.
func (*RetryAfterError) Error ¶
func (e *RetryAfterError) Error() string
Error returns a string representation of the RetryAfter error.
type RetryOption ¶
type RetryOption func(*retryOptions)
func WithBackOff ¶
func WithBackOff(b BackOff) RetryOption
WithBackOff configures a custom backoff strategy.
func WithMaxElapsedTime ¶
func WithMaxElapsedTime(d time.Duration) RetryOption
WithMaxElapsedTime limits the total duration for retry attempts.
func WithMaxTries ¶
func WithMaxTries(n uint) RetryOption
WithMaxTries limits the number of retry attempts.
func WithNotify ¶
func WithNotify(n Notify) RetryOption
WithNotify sets a notification function to handle retry errors.
type StopBackOff ¶
type StopBackOff struct{}
StopBackOff is a fixed backoff policy that always returns backoff.Stop for NextBackOff(), meaning that the operation should never be retried.
func (*StopBackOff) NextBackOff ¶
func (b *StopBackOff) NextBackOff() time.Duration
func (*StopBackOff) Reset ¶
func (b *StopBackOff) Reset()
type Ticker ¶
Ticker holds a channel that delivers `ticks' of a clock at times reported by a BackOff.
Ticks will continue to arrive when the previous operation is still running, so operations that take a while to fail could run in quick succession.
Example ¶
// An operation that may fail.
operation := func() (string, error) {
return "hello", nil
}
ticker := backoff.NewTicker(backoff.NewExponentialBackOff())
defer ticker.Stop()
var result string
var err error
// Ticks will continue to arrive when the previous operation is still running,
// so operations that take a while to fail could run in quick succession.
for range ticker.C {
if result, err = operation(); err != nil {
log.Println(err, "will retry...")
continue
}
break
}
if err != nil {
// Operation has failed.
fmt.Println("Error:", err)
return
}
// Operation is successful.
fmt.Println(result)
Output: hello
func NewTicker ¶
NewTicker returns a new Ticker containing a channel that will send the time at times specified by the BackOff argument. Ticker is guaranteed to tick at least once. The channel is closed when Stop method is called or BackOff stops. It is not safe to manipulate the provided backoff policy (notably calling NextBackOff or Reset) while the ticker is running.
type ZeroBackOff ¶
type ZeroBackOff struct{}
ZeroBackOff is a fixed backoff policy whose backoff time is always zero, meaning that the operation is retried immediately without waiting, indefinitely.
func (*ZeroBackOff) NextBackOff ¶
func (b *ZeroBackOff) NextBackOff() time.Duration
func (*ZeroBackOff) Reset ¶
func (b *ZeroBackOff) Reset()
Source Files