resilience

type Backoff func(attempt int) time.Duration

type Breaker struct {
	// contains filtered or unexported fields
}

type BreakerConfig struct {
	// Name is included in callbacks for observability.
	Name string
	// MaxRequests is the number of trial calls allowed in half-open before
	// the breaker decides. Defaults to 1.
	MaxRequests uint32
	// OpenTimeout is how long the breaker stays open before moving to
	// half-open. Defaults to 60s.
	OpenTimeout time.Duration
	// MinRequests is the minimum number of requests in a generation before
	// the failure-ratio threshold is considered. Defaults to 0 (always
	// considered).
	MinRequests uint32
	// FailureRatio trips the breaker when the failure ratio meets or
	// exceeds this value (and MinRequests is satisfied). 0 disables the
	// ratio rule.
	FailureRatio float64
	// ConsecutiveFailures trips the breaker when this many calls fail in a
	// row. 0 disables the consecutive rule. If both rules are disabled the
	// default ConsecutiveFailures of 5 is applied.
	ConsecutiveFailures uint32
	// IsSuccessful classifies an error as a success (true) or failure
	// (false). Defaults to "nil error == success". Use it to treat, e.g.,
	// context.Canceled or 4xx as non-failures.
	IsSuccessful func(err error) bool
	// OnStateChange is called on every state transition.
	OnStateChange func(name string, from, to State)
	// Clock is the time source; defaults to SystemClock.
	Clock Clock
}

type Bulkhead struct {
	// contains filtered or unexported fields
}

type BulkheadConfig struct {
	// MaxConcurrent caps the number of calls running at once. Defaults to 1.
	// Values < 1 are raised to 1.
	MaxConcurrent int
	// MaxQueue caps how many extra callers may wait for a slot. 0 means no
	// queue: a call is rejected the instant all slots are busy. Values < 0
	// are treated as 0.
	MaxQueue int
}

type Clock interface {
	// Now returns the current time.
	Now() time.Time
	// After returns a channel that receives once d has elapsed.
	After(d time.Duration) <-chan time.Time
	// Sleep blocks for d (or until the channel from After would fire).
	Sleep(d time.Duration)
}

type Counts struct {
	Requests            uint32
	TotalSuccesses      uint32
	TotalFailures       uint32
	ConsecutiveSuccess  uint32
	ConsecutiveFailures uint32
}

type FakeClock struct {
	// contains filtered or unexported fields
}

type JitterSource interface {
	// Float64 returns a value in [0,1).
	Float64() float64
}

type Middleware func(Operation) Operation

type Operation func(ctx context.Context) (any, error)

type RateLimiter struct {
	// contains filtered or unexported fields
}

type RateLimiterConfig struct {
	// Rate is the steady-state token refill rate in tokens per second.
	// Defaults to 1. Values <= 0 are raised to 1.
	Rate float64
	// Burst is the bucket capacity — the largest momentary burst allowed.
	// Defaults to 1. Values < 1 are raised to 1.
	Burst int
	// Clock is the time source; defaults to SystemClock. Inject a FakeClock
	// in tests to advance time deterministically.
	Clock Clock
}

type Retry struct {
	// contains filtered or unexported fields
}

type RetryConfig struct {
	// MaxAttempts is the total number of calls (initial try + retries).
	// Defaults to 3. Values < 1 are raised to 1.
	MaxAttempts int
	// Backoff computes the wait between attempts. Defaults to a constant
	// 100ms.
	Backoff Backoff
	// RetryIf decides whether an error is worth retrying. Defaults to
	// "retry on any non-nil error". It is never consulted for a nil error
	// (success), nor after the final attempt.
	RetryIf func(err error) bool
	// Clock is the time source used to sleep between attempts; defaults to
	// SystemClock. Inject a FakeClock in tests.
	Clock Clock
}

type State int

type Timeout struct {
	// contains filtered or unexported fields
}

type TimeoutConfig struct {
	// Duration is the per-call bound. A non-positive Duration disables the
	// bound (fn runs without an added deadline).
	Duration time.Duration
	// Clock is reserved for time reads; defaults to SystemClock. The
	// derived deadline itself uses context.WithTimeout so cancellation
	// propagates to fn.
	Clock Clock
}