Package: github.com/cenkalti/backoff/v5

package backoff Import Path github.com/cenkalti/backoff/v5 (on go.dev) Dependency Relation imports 6 packages, and imported by one package

Involved Source Files d backoff.go 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. error.go exponential.go retry.go ticker.go timer.go

Code Examples Retry { operation := func() (string, error) { resp, err := http.Get("http://httpbin.org/get") if err != nil { return "", err } defer resp.Body.Close() if resp.StatusCode == 400 { return "", backoff.Permanent(errors.New("bad request")) } if resp.StatusCode == 429 { seconds, err := strconv.ParseInt(resp.Header.Get("Retry-After"), 10, 64) if err == nil { return "", backoff.RetryAfter(int(seconds)) } } return "hello", nil } result, err := backoff.Retry(context.TODO(), operation, backoff.WithBackOff(backoff.NewExponentialBackOff())) if err != nil { fmt.Println("Error:", err) return } fmt.Println(result) } Ticker { operation := func() (string, error) { return "hello", nil } ticker := backoff.NewTicker(backoff.NewExponentialBackOff()) defer ticker.Stop() var result string var err error for range ticker.C { if result, err = operation(); err != nil { log.Println(err, "will retry...") continue } break } if err != nil { fmt.Println("Error:", err) return } fmt.Println(result) }

Package-Level Functions (total 10)

func NewConstantBackOff(d time.Duration) *ConstantBackOff

func NewExponentialBackOff() *ExponentialBackOff NewExponentialBackOff creates an instance of ExponentialBackOff using default values.

func NewTicker(b BackOff) *Ticker 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.

func Permanent(err error) error Permanent wraps the given err in a *PermanentError.

func Retry[T](ctx context.Context, operation Operation[T], opts ...RetryOption) (T, error) Type Parameters: T: any 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.

func RetryAfter(seconds int) error RetryAfter returns a RetryAfter error that specifies how long to wait before retrying.

func WithBackOff(b BackOff) RetryOption WithBackOff configures a custom backoff strategy.

func WithMaxElapsedTime(d time.Duration) RetryOption WithMaxElapsedTime limits the total duration for retry attempts.

func WithMaxTries(n uint) RetryOption WithMaxTries limits the number of all attempts.

func WithNotify(n Notify) RetryOption WithNotify sets a notification function to handle retry errors.

Package-Level Constants (total 6)

const DefaultInitialInterval time.Duration = 500000000 Default values for ExponentialBackOff.

const DefaultMaxElapsedTime time.Duration = 900000000000 DefaultMaxElapsedTime sets a default limit for the total retry duration.

const DefaultMaxInterval time.Duration = 60000000000 Default values for ExponentialBackOff.

const DefaultMultiplier = 1.5 Default values for ExponentialBackOff.

const DefaultRandomizationFactor = 0.5 Default values for ExponentialBackOff.

const Stop time.Duration = -1 Stop indicates that no more retries should be made for use in NextBackOff().