ambatukam

package module

Go to main page

Versions in this module

v1

v1.2.5

Jul 25, 2026

Changes in this version

+ func WithPriority(ctx context.Context) context.Context

+ type AdaptiveTimeoutConfig struct

+ Initial time.Duration

+ MinSamples int

+ Percentile int

+ Window time.Duration

+ type AdaptiveTimeoutPolicy struct

+ func NewAdaptiveTimeout(cfg AdaptiveTimeoutConfig) *AdaptiveTimeoutPolicy

+ func (at *AdaptiveTimeoutPolicy) CurrentTimeout() time.Duration

+ func (at *AdaptiveTimeoutPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ func (at *AdaptiveTimeoutPolicy) WithMetrics(m MetricsRecorder) *AdaptiveTimeoutPolicy

type BulkheadConfig

+ Priority bool

+ type CacheConfig struct

+ MaxEntries int

+ Methods []string

+ TTL time.Duration

+ type CachePolicy struct

+ func NewCache(cfg CacheConfig) *CachePolicy

+ func (c *CachePolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ func (c *CachePolicy) SetStats(s *statsRecorder)

type Client

+ func (c *Client) Stats() ClientStats

+ type ClientStats struct

+ AvgResponseTimeNs int64

+ BulkheadDenied uint64

+ BulkheadInFlight uint32

+ CacheHits uint64

+ CacheMisses uint64

+ CircuitState State

+ FallbacksTotal uint64

+ RateLimitTokens int

+ RequestsFailed uint64

+ RequestsTotal uint64

+ RetriesTotal uint64

+ TimeoutsTotal uint64

+ Uptime time.Duration

+ type Interceptor func(req *http.Request, next PolicyFunc) (*http.Response, error)

type Option

+ func WithAdaptiveTimeout(cfg AdaptiveTimeoutConfig) Option

+ func WithCache(cfg CacheConfig) Option

+ func WithInterceptor(i Interceptor) Option

+ func WithRequestLog(cfg RequestLogConfig) Option

+ func WithRetryBudget(budget float64, window time.Duration) Option

type RateLimitPolicy

+ func (r *RateLimitPolicy) AvailableTokens() int

+ type RequestLogConfig struct

+ LogBody bool

+ LogHeaders []string

+ Logger *slog.Logger

+ type RequestLogger struct

+ func NewRequestLogger(cfg RequestLogConfig) *RequestLogger

+ func (rl *RequestLogger) Wrap(next PolicyFunc) PolicyFunc

+ type RetryBudget struct

+ func NewRetryBudget(budget float64, window time.Duration) *RetryBudget

+ func (rb *RetryBudget) Allow() bool

+ func (rb *RetryBudget) Stats() (total, retries int64)

type RetryPolicy

+ func (r *RetryPolicy) WithBudget(b *RetryBudget) *RetryPolicy

v1.2.4

Jul 25, 2026

Changes in this version

type Client

+ func (c *Client) Delete(ctx context.Context, url string) (*http.Response, error)

+ func (c *Client) Head(ctx context.Context, url string) (*http.Response, error)

+ func (c *Client) Options(ctx context.Context, url string) (*http.Response, error)

+ func (c *Client) Patch(ctx context.Context, url, contentType string, body io.Reader) (*http.Response, error)

+ func (c *Client) Put(ctx context.Context, url, contentType string, body io.Reader) (*http.Response, error)

type Option

+ func WithMaxBodySize(n int64) Option

type RetryConfig

+ MaxBodySize int64

type SingleflightPolicy

+ func (sf *SingleflightPolicy) SetMaxBodySize(n int64)

v1.2.3

Jul 24, 2026

v1.2.2

Jun 29, 2026

Changes in this version

type BulkheadPolicy

+ func (b *BulkheadPolicy) Close()

type RateLimitPolicy

+ func (r *RateLimitPolicy) Close()

v1.2.1

Jun 27, 2026

Changes in this version

type BulkheadPolicy

+ func (b *BulkheadPolicy) WithMetrics(m MetricsRecorder) *BulkheadPolicy

type CircuitBreakerPolicy

+ func (cb *CircuitBreakerPolicy) WithMetrics(m MetricsRecorder) *CircuitBreakerPolicy

type FallbackPolicy

+ func (f *FallbackPolicy) WithMetrics(m MetricsRecorder) *FallbackPolicy

type HealthChecker

+ func (h *HealthChecker) Close()

type RateLimitPolicy

+ func (r *RateLimitPolicy) WithMetrics(m MetricsRecorder) *RateLimitPolicy

type RetryPolicy

+ func (r *RetryPolicy) WithMetrics(m MetricsRecorder) *RetryPolicy

type TimeoutMapPolicy

+ func (t *TimeoutMapPolicy) WithMetrics(m MetricsRecorder) *TimeoutMapPolicy

type TimeoutPolicy

+ func (t *TimeoutPolicy) WithMetrics(m MetricsRecorder) *TimeoutPolicy

v1.2.0

Jun 27, 2026

Changes in this version

+ type Counter interface

+ Add func(float64)

+ Inc func()

+ type CounterVec interface

+ WithLabelValues func(lvs ...string) Counter

+ type Gauge interface

+ Dec func()

+ Inc func()

+ Set func(float64)

+ type GaugeVec interface

+ WithLabelValues func(lvs ...string) Gauge

+ type Histogram interface

+ Observe func(float64)

+ type HistogramVec interface

+ WithLabelValues func(lvs ...string) Histogram

+ type Logger interface

+ Debug func(msg string, args ...any)

+ Error func(msg string, args ...any)

+ Info func(msg string, args ...any)

+ Warn func(msg string, args ...any)

type Option

+ func WithCustomLogger(l Logger) Option

+ func WithTimeoutMap(rules map[string]time.Duration) Option

+ type PrometheusConfig struct

+ BulkheadDenied CounterVec

+ CircuitState GaugeVec

+ CircuitTransitions CounterVec

+ FallbacksTotal CounterVec

+ RateLimitDenied CounterVec

+ RequestDuration HistogramVec

+ RequestsTotal CounterVec

+ RetriesTotal CounterVec

+ TimeoutsTotal CounterVec

+ type PrometheusRecorder struct

+ func NewPrometheusRecorder(cfg PrometheusConfig) *PrometheusRecorder

+ func (r *PrometheusRecorder) RecordBulkheadDenied(method, url string)

+ func (r *PrometheusRecorder) RecordCircuitStateChange(name string, from, to State)

+ func (r *PrometheusRecorder) RecordFallback(method, url string)

+ func (r *PrometheusRecorder) RecordRateLimitDenied(method, url string)

+ func (r *PrometheusRecorder) RecordRequest(method, url string, status int, duration time.Duration)

+ func (r *PrometheusRecorder) RecordRetry(method, url string, attempt int)

+ func (r *PrometheusRecorder) RecordTimeout(method, url string)

+ type TimeoutMapPolicy struct

+ func NewTimeoutMap(rules map[string]time.Duration) *TimeoutMapPolicy

+ func (t *TimeoutMapPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

v1.1.0

Jun 26, 2026

Changes in this version

+ var ErrFallback = errors.New("ambatukam: fallback failed")

type Client

+ func (c *Client) HealthChecker() *HealthChecker

+ type FallbackConfig struct

+ Handler func(req *http.Request, err error) (*http.Response, error)

+ type FallbackPolicy struct

+ func NewFallback(cfg FallbackConfig) *FallbackPolicy

+ func (f *FallbackPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ func (f *FallbackPolicy) WithHooks(h Hooks) *FallbackPolicy

+ type HealthChecker struct

+ func NewHealthChecker(c *Client) *HealthChecker

+ func (h *HealthChecker) Handler() http.HandlerFunc

+ type HealthStatus struct

+ Memory MemoryStats

+ Policies map[string]string

+ Status string

+ Timestamp time.Time

+ Uptime time.Duration

type Hooks

+ OnFallback func(req *http.Request, err error)

+ type MemoryStats struct

+ Alloc uint64

+ NumGC uint32

+ Sys uint64

+ TotalAlloc uint64

+ type MetricsRecorder interface

+ RecordBulkheadDenied func(method, url string)

+ RecordCircuitStateChange func(name string, from, to State)

+ RecordFallback func(method, url string)

+ RecordRateLimitDenied func(method, url string)

+ RecordRequest func(method, url string, status int, duration time.Duration)

+ RecordRetry func(method, url string, attempt int)

+ RecordTimeout func(method, url string)

+ func NewNoopMetricsRecorder() MetricsRecorder

type Option

+ func WithFallback(cfg FallbackConfig) Option

+ func WithMetrics(r MetricsRecorder) Option

+ func WithSingleflight() Option

type RequestError

+ Policy string

+ type SingleflightConfig struct

+ Enabled bool

+ type SingleflightPolicy struct

+ func NewSingleflight() *SingleflightPolicy

+ func (sf *SingleflightPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

v1.0.0

Jun 26, 2026

Changes in this version

+ var ErrBulkheadFull = errors.New("ambatukam: bulkhead full")

+ var ErrCircuitOpen = errors.New("ambatukam: circuit breaker is open")

+ var ErrMaxRetries = errors.New("ambatukam: max retries exceeded")

+ var ErrNilRequest = errors.New("ambatukam: nil request")

+ var ErrRateLimited = errors.New("ambatukam: rate limited")

+ var ErrTimeout = errors.New("ambatukam: per-attempt timeout exceeded")

+ func GetJSON[T any](c *Client, ctx context.Context, url string) (T, error)

+ func Permanent(err error) error

+ func PostJSON[T any](c *Client, ctx context.Context, url string, body any) (T, error)

+ type Backoff interface

+ NextDelay func(attempt int) time.Duration

+ func ConstantBackoff(d time.Duration) Backoff

+ func ExponentialBackoff(initial, max time.Duration, multiplier float64) Backoff

+ func LinearBackoff(initial, max, step time.Duration) Backoff

+ type BulkheadConfig struct

+ MaxConcurrent uint32

+ MaxQueue uint32

+ QueueTimeout time.Duration

+ type BulkheadPolicy struct

+ func NewBulkhead(cfg BulkheadConfig) *BulkheadPolicy

+ func (b *BulkheadPolicy) Denied() uint64

+ func (b *BulkheadPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ func (b *BulkheadPolicy) InFlight() uint32

+ func (b *BulkheadPolicy) WithLogger(l *slog.Logger) *BulkheadPolicy

+ type CircuitBreakerPolicy struct

+ func NewCircuitBreaker(cfg CircuitConfig) *CircuitBreakerPolicy

+ func (cb *CircuitBreakerPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ func (cb *CircuitBreakerPolicy) State() State

+ func (cb *CircuitBreakerPolicy) WithHooks(h Hooks) *CircuitBreakerPolicy

+ func (cb *CircuitBreakerPolicy) WithLogger(l *slog.Logger) *CircuitBreakerPolicy

+ func (cb *CircuitBreakerPolicy) WithName(name string) *CircuitBreakerPolicy

+ type CircuitConfig struct

+ FailureThreshold uint32

+ HalfOpenMaxReqs uint32

+ OpenDuration time.Duration

+ ShouldTrip func(resp *http.Response, err error) bool

+ func DefaultCircuitConfig() CircuitConfig

+ type Client struct

+ func New(opts ...Option) *Client

+ func NewDefaultClient() *Client

+ func (c *Client) Close() error

+ func (c *Client) Do(req *http.Request) (*http.Response, error)

+ func (c *Client) DoWithContext(ctx context.Context, req *http.Request) (*http.Response, error)

+ func (c *Client) Get(ctx context.Context, url string) (*http.Response, error)

+ func (c *Client) Post(ctx context.Context, url, contentType string, body io.Reader) (*http.Response, error)

+ func (c *Client) RoundTrip(req *http.Request) (*http.Response, error)

+ func (c *Client) Transport() http.RoundTripper

+ type Hooks struct

+ AfterResponse func(req *http.Request, resp *http.Response, err error)

+ BeforeRequest func(req *http.Request) error

+ OnRetry func(req *http.Request, attempt int, nextDelay time.Duration)

+ OnStateChange func(name string, from, to State)

+ type Option func(*Client)

+ func AggressiveConfig() []Option

+ func ConservativeConfig() []Option

+ func DefaultConfig() []Option

+ func ProductionConfig() []Option

+ func WithBulkhead(cfg BulkheadConfig) Option

+ func WithCircuitBreaker(cfg CircuitConfig) Option

+ func WithDebug() Option

+ func WithHTTPClient(hc *http.Client) Option

+ func WithHooks(h Hooks) Option

+ func WithLogger(l *slog.Logger) Option

+ func WithPolicy(p Policy) Option

+ func WithRateLimit(cfg RateLimitConfig) Option

+ func WithRequestID(header string) Option

+ func WithRequestIDPolicy(p *RequestIDPolicy) Option

+ func WithRetry(cfg RetryConfig) Option

+ func WithTimeout(cfg TimeoutConfig) Option

+ type PermanentError struct

+ Err error

+ func (e *PermanentError) Error() string

+ func (e *PermanentError) Unwrap() error

+ type Policy interface

+ Execute func(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ func Chain(policies ...Policy) Policy

+ type PolicyFunc func(ctx context.Context, req *http.Request) (*http.Response, error)

+ func (f PolicyFunc) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ type RateLimitConfig struct

+ Burst uint32

+ Rate float64

+ WaitTimeout time.Duration

+ type RateLimitPolicy struct

+ func NewRateLimit(cfg RateLimitConfig) *RateLimitPolicy

+ func (r *RateLimitPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ func (r *RateLimitPolicy) WithLogger(l *slog.Logger) *RateLimitPolicy

+ type RequestError struct

+ Attempts int

+ Err error

+ Method string

+ Status int

+ URL string

+ func (e *RequestError) Error() string

+ func (e *RequestError) Unwrap() error

+ type RequestIDPolicy struct

+ func NewRequestIDPolicy() *RequestIDPolicy

+ func (r *RequestIDPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ func (r *RequestIDPolicy) WithGenerator(gen func() string) *RequestIDPolicy

+ func (r *RequestIDPolicy) WithHeader(name string) *RequestIDPolicy

+ type RetryConfig struct

+ Backoff Backoff

+ InitialBackoff time.Duration

+ Jitter float64

+ MaxBackoff time.Duration

+ MaxRetries int

+ Multiplier float64

+ ShouldRetry func(resp *http.Response, err error) bool

+ func DefaultRetryConfig() RetryConfig

+ type RetryPolicy struct

+ func NewRetry(cfg RetryConfig) *RetryPolicy

+ func (r *RetryPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

+ func (r *RetryPolicy) WithHooks(h Hooks) *RetryPolicy

+ func (r *RetryPolicy) WithLogger(l *slog.Logger) *RetryPolicy

+ type State string

+ const StateClosed

+ const StateHalfOpen

+ const StateOpen

+ type TimeoutConfig struct

+ Timeout time.Duration

+ type TimeoutPolicy struct

+ func NewTimeout(cfg TimeoutConfig) *TimeoutPolicy

+ func (t *TimeoutPolicy) Execute(ctx context.Context, req *http.Request, next PolicyFunc) (*http.Response, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL