retry

Documentation

Index

• Constants
• type DeadlineAwareRetryStrategy
• type DefaultEligibilityStrategy
  • func (s DefaultEligibilityStrategy) IsEligibleForRetry(props StrategyProps) bool
• type EligibilityStrategy
• type ExponentialBackoffRetryStrategy
• type ExponentialBackoffRetryStrategyProps
• type FixedCountRetryStrategy
• type FixedCountRetryStrategyProps
• type FixedTimeoutRetryStrategy
• type FixedTimeoutRetryStrategyProps
• type LegacyTopicSubscriptionRetryStrategy
• type LegacyTopicSubscriptionRetryStrategyProps
• type OverrideDeadlineRetryStrategy
• type Strategy
  • func NewExponentialBackoffRetryStrategy(props ExponentialBackoffRetryStrategyProps) Strategy
  • func NewFixedCountRetryStrategy(props FixedCountRetryStrategyProps) Strategy
  • func NewFixedTimeoutRetryStrategy(props FixedTimeoutRetryStrategyProps) Strategy
  • func NewLegacyTopicSubscriptionRetryStrategy(props LegacyTopicSubscriptionRetryStrategyProps) Strategy
  • func NewNeverRetryStrategy() Strategy
  • func NewTimeoutAwareFixedCountRetryStrategy(props TimeoutAwareFixedCountRetryStrategyProps) Strategy
• type StrategyProps
• type TimeoutAwareEligibilityStrategy
  • func (s TimeoutAwareEligibilityStrategy) IsEligibleForRetry(props StrategyProps) bool
• type TimeoutAwareFixedCountRetryStrategy
• type TimeoutAwareFixedCountRetryStrategyProps

Constants

const (
	DefaultInitialDelayMs = 0.5
	DefaultGrowthFactor   = 2
	DefaultMaxBackoffMs   = 8
)

const (
	// DefaultRetryTimeoutMillis is the number of milliseconds the client is willing to wait for
	// a response on a retry attempt. Defaults to 1 second.
	DefaultRetryTimeoutMillis = 1000
	// DefaultRetryDelayIntervalMillis is the number of milliseconds to wait between retry attempts.
	// Defaults to 100ms +/- jitter.
	DefaultRetryDelayIntervalMillis = 100
)

const (
	// DefaultRetryTimeoutDuration is the duration the client is willing to wait for
	// a response on a retry attempt. Defaults to 500 milliseconds.
	DefaultRetryTimeoutDuration = 500 * time.Millisecond
)

Types

type DeadlineAwareRetryStrategy

type DeadlineAwareRetryStrategy interface {
	Strategy

	// CalculateRetryDeadline calculates the deadline for a retry attempt.
	// Returns nil if there is no adjustment to the deadline.
	CalculateRetryDeadline(overallDeadline time.Time) time.Time
}

type DefaultEligibilityStrategy

type DefaultEligibilityStrategy struct{}

DefaultEligibilityStrategy is the default strategy for determining if a request is eligible for retry.

func (DefaultEligibilityStrategy) IsEligibleForRetry

func (s DefaultEligibilityStrategy) IsEligibleForRetry(props StrategyProps) bool

type EligibilityStrategy

type EligibilityStrategy interface {
	// IsEligibleForRetry Determines whether a grpc call is able to be retried. The determination is based on the result
	// of the last invocation of the call and whether the call is idempotent.
	IsEligibleForRetry(props StrategyProps) bool
}

type ExponentialBackoffRetryStrategy

type ExponentialBackoffRetryStrategy interface {
	Strategy
	WithInitialDelayMillis(float32) Strategy
	WithMaxBackoffMillis(int) Strategy
	WithEligibilityStrategy(EligibilityStrategy) Strategy
	WithGrowthFactor(int) Strategy
}

type ExponentialBackoffRetryStrategyProps

type ExponentialBackoffRetryStrategyProps struct {
	LoggerFactory       logger.MomentoLoggerFactory
	EligibilityStrategy EligibilityStrategy
	InitialDelayMillis  float64
	MaxBackoffMillis    int
	GrowthFactor        int
}

type FixedCountRetryStrategy

type FixedCountRetryStrategy interface {
	Strategy
	WithMaxAttempts(attempts int) Strategy
	WithEligibilityStrategy(s EligibilityStrategy) Strategy
}

type FixedCountRetryStrategyProps

type FixedCountRetryStrategyProps struct {
	LoggerFactory       logger.MomentoLoggerFactory
	MaxAttempts         int
	EligibilityStrategy EligibilityStrategy
}

type FixedTimeoutRetryStrategy

type FixedTimeoutRetryStrategy interface {
	DeadlineAwareRetryStrategy
	WithRetryTimeoutMillis(timeout int) Strategy
	WithRetryDelayIntervalMillis(delay int) Strategy
	WithEligibilityStrategy(s EligibilityStrategy) Strategy
}

FixedTimeoutRetryStrategy is a retry strategy that retries a request up until the client timeout is reached. After the initial request fails, the next retry will be scheduled for retryDelayIntervalMillis from the current time, and the retried request will timeout after retryTimeoutMillis if there is no response.

type FixedTimeoutRetryStrategyProps

type FixedTimeoutRetryStrategyProps struct {
	EligibilityStrategy      EligibilityStrategy
	LoggerFactory            logger.MomentoLoggerFactory
	RetryTimeoutMillis       int
	RetryDelayIntervalMillis int
}

type LegacyTopicSubscriptionRetryStrategy

type LegacyTopicSubscriptionRetryStrategy interface {
	Strategy
	WithRetryMs(ms int) Strategy
}

type LegacyTopicSubscriptionRetryStrategyProps

type LegacyTopicSubscriptionRetryStrategyProps struct {
	LoggerFactory logger.MomentoLoggerFactory
	RetryMs       *int
}

type OverrideDeadlineRetryStrategy

type OverrideDeadlineRetryStrategy interface {
	Strategy

	// CalculateNewOverallDeadline calculates the deadline for a retry attempt and uses it to override the overall deadline.
	// Returns nil if there is no adjustment to the deadline.
	CalculateNewOverallDeadline() time.Time
}

type Strategy

type Strategy interface {
	// DetermineWhenToRetry Determines whether a grpc call can be retried and how long to wait before that retry.
	//
	// StrategyProps - Information about the grpc call, its last invocation, and how many times the call
	// has been made.
	//
	// Returns The time in milliseconds before the next retry should occur or nil if no retry should be attempted.
	DetermineWhenToRetry(props StrategyProps) *int
}

func NewExponentialBackoffRetryStrategy

func NewExponentialBackoffRetryStrategy(props ExponentialBackoffRetryStrategyProps) Strategy

func NewFixedCountRetryStrategy

func NewFixedCountRetryStrategy(props FixedCountRetryStrategyProps) Strategy

func NewFixedTimeoutRetryStrategy

func NewFixedTimeoutRetryStrategy(props FixedTimeoutRetryStrategyProps) Strategy

func NewLegacyTopicSubscriptionRetryStrategy

func NewLegacyTopicSubscriptionRetryStrategy(props LegacyTopicSubscriptionRetryStrategyProps) Strategy

NewLegacyTopicSubscriptionRetryStrategy returns a strategy that always retries any request after a fixed delay. It is intended to maintain compatibility with the legacy behavior of Momento Topic subscriptions, which are now able to specify a retry strategy for determining when to reconnect to a subscription that has been interrupted. Switching to any of the other available retry strategies is recommended but not required and may require additional error handling after `Item()` or `Event()` calls as errors that previously resulted in a retry will now be returned to the caller. Deprecated: This strategy is deprecated and will be removed in a future release.

func NewNeverRetryStrategy

func NewNeverRetryStrategy() Strategy

NewNeverRetryStrategy is a retry strategy that never retries any request

func NewTimeoutAwareFixedCountRetryStrategy

func NewTimeoutAwareFixedCountRetryStrategy(props TimeoutAwareFixedCountRetryStrategyProps) Strategy

type StrategyProps

type StrategyProps struct {
	GrpcStatusCode codes.Code
	GrpcMethod     string
	AttemptNumber  int

	// OverallDeadline is the overall deadline for the request. It is currently only used
	// by the FixedTimeoutRetryStrategy to determine when to stop retrying.
	OverallDeadline time.Time
}

type TimeoutAwareEligibilityStrategy

type TimeoutAwareEligibilityStrategy struct{}

TimeoutAwareEligibilityStrategy is an eligibility strategy that treats DeadlineExceeded as retryable. It is used in conjunction with the TimeoutAwareFixedCountRetryStrategy.

Typically, a DeadlineExceeded would indicate that the overall client timeout has been reached and no further retries should be attempted. However, there are some cases where timeouts may occur due to the client being overloaded or experiencing transient network issues. In these cases, it may be beneficial to retry the request even if the overall timeout has been reached.

func (TimeoutAwareEligibilityStrategy) IsEligibleForRetry

func (s TimeoutAwareEligibilityStrategy) IsEligibleForRetry(props StrategyProps) bool

type TimeoutAwareFixedCountRetryStrategy

type TimeoutAwareFixedCountRetryStrategy interface {
	Strategy
	WithMaxAttempts(attempts int) Strategy
	WithEligibilityStrategy(s EligibilityStrategy) Strategy
	WithTimeoutDuration(duration time.Duration) Strategy
}

TimeoutAwareFixedCountRetryStrategy is a retry strategy that treats DeadlineExceeded as retryable. It is used in conjunction with the TimeoutAwareEligibilityStrategy.

Typically, a DeadlineExceeded would indicate that the overall client timeout has been reached and no further retries should be attempted. However, there are some cases where timeouts may occur due to the client being overloaded or experiencing transient network issues. In these cases, it may be beneficial to retry the request even if the overall timeout has been reached.

Note that this is different than using the FixedTimeoutRetryStrategy, which does not attempt a retry with a shorter timeout until after the first request fails due to a non-timeout error, and will retry only until the client's overall timeout is reached.

type TimeoutAwareFixedCountRetryStrategyProps

type TimeoutAwareFixedCountRetryStrategyProps struct {
	LoggerFactory       logger.MomentoLoggerFactory
	MaxAttempts         int
	EligibilityStrategy EligibilityStrategy
	TimeoutDuration     time.Duration
}