backoff

README

Exponential Backoff

This is a fork of cenkalti/backoff v4.0, with some unused features removed.

This package is a Go port of the exponential backoff algorithm from [Google's HTTP Client Library for Java][google-http-java-client].

[Exponential backoff][exponential backoff wiki] 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.

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
• Variables
• type BackOff
  • func WithMaxRetries(b BackOff, max uint64) BackOff
• type Clock
• type ConstantBackOff
  • func NewConstantBackOff(d time.Duration) *ConstantBackOff
  • func (b *ConstantBackOff) NextBackOff() time.Duration
  • func (b *ConstantBackOff) Reset()
• type ExponentialBackOff
  • func NewExponentialBackOff(opts ...ExponentialBackOffOpts) *ExponentialBackOff
  • func (b *ExponentialBackOff) GetElapsedTime() time.Duration
  • func (b *ExponentialBackOff) NextBackOff() time.Duration
  • func (b *ExponentialBackOff) Reset()
• type ExponentialBackOffOpts
  • func WithClockProvider(clock Clock) ExponentialBackOffOpts
  • func WithInitialInterval(duration time.Duration) ExponentialBackOffOpts
  • func WithMaxElapsedTime(duration time.Duration) ExponentialBackOffOpts
  • func WithMaxInterval(duration time.Duration) ExponentialBackOffOpts
  • func WithMultiplier(multiplier float64) ExponentialBackOffOpts
  • func WithRandomizationFactor(randomizationFactor float64) ExponentialBackOffOpts
  • func WithRetryStopDuration(duration time.Duration) ExponentialBackOffOpts
• type StopBackOff
  • func (b *StopBackOff) NextBackOff() time.Duration
  • func (b *StopBackOff) Reset()
• type ZeroBackOff
  • func (b *ZeroBackOff) NextBackOff() time.Duration
  • func (b *ZeroBackOff) Reset()

Constants

const (
	DefaultInitialInterval     = 500 * time.Millisecond
	DefaultRandomizationFactor = 0.5
	DefaultMultiplier          = 1.5
	DefaultMaxInterval         = 60 * time.Second
	DefaultMaxElapsedTime      = 15 * time.Minute
)

Default values for ExponentialBackOff.

const Stop time.Duration = -1

Stop indicates that no more retries should be made for use in NextBackOff().

Variables

var SystemClock = systemClock{}

SystemClock implements Clock interface that uses time.Now().

Types

type BackOff

type BackOff interface {
	// NextBackOff returns the duration to wait before retrying the operation,
	// or 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.

func WithMaxRetries

func WithMaxRetries(b BackOff, max uint64) BackOff

WithMaxRetries creates a wrapper around another BackOff, which will return Stop if NextBackOff() has been called too many times since the last time Reset() was called

Note: Implementation is not thread-safe.

type Clock

type Clock interface {
	Now() time.Time
}

Clock is an interface that returns current time for BackOff.

type ConstantBackOff

type ConstantBackOff struct {
	Interval time.Duration
}

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
	// After MaxElapsedTime the ExponentialBackOff returns Stop.
	// It never stops if MaxElapsedTime == 0.
	MaxElapsedTime time.Duration
	Stop           time.Duration
	Clock          Clock
	// 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(opts ...ExponentialBackOffOpts) *ExponentialBackOff

NewExponentialBackOff creates an instance of ExponentialBackOff using default values.

func (*ExponentialBackOff) GetElapsedTime

func (b *ExponentialBackOff) GetElapsedTime() time.Duration

GetElapsedTime returns the elapsed time since an ExponentialBackOff instance is created and is reset when Reset() is called.

The elapsed time is computed using time.Now().UnixNano(). It is safe to call even while the backoff policy is used by a running ticker.

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 ExponentialBackOffOpts

type ExponentialBackOffOpts func(*ExponentialBackOff)

ExponentialBackOffOpts is a function type used to configure ExponentialBackOff options.

func WithClockProvider

func WithClockProvider(clock Clock) ExponentialBackOffOpts

WithClockProvider sets the clock used to measure time.

func WithInitialInterval

func WithInitialInterval(duration time.Duration) ExponentialBackOffOpts

WithInitialInterval sets the initial interval between retries.

func WithMaxElapsedTime

func WithMaxElapsedTime(duration time.Duration) ExponentialBackOffOpts

WithMaxElapsedTime sets the maximum total time for retries.

func WithMaxInterval

func WithMaxInterval(duration time.Duration) ExponentialBackOffOpts

WithMaxInterval sets the maximum interval between retries.

func WithMultiplier

func WithMultiplier(multiplier float64) ExponentialBackOffOpts

WithMultiplier sets the multiplier for increasing the interval after each retry.

func WithRandomizationFactor

func WithRandomizationFactor(randomizationFactor float64) ExponentialBackOffOpts

WithRandomizationFactor sets the randomization factor to add jitter to intervals.

func WithRetryStopDuration

func WithRetryStopDuration(duration time.Duration) ExponentialBackOffOpts

WithRetryStopDuration sets the duration after which retries should stop.

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 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()