limiters

type Clock ¶

type Clock interface {
	// Now returns the current system time.
	Now() time.Time
}

Clock encapsulates a system Clock. Used

type ConcurrentBufferBackend ¶

type ConcurrentBufferBackend interface {
	// Add adds the request with the given key to the buffer and returns the total number of requests in it.
	Add(ctx context.Context, key string) (int64, error)
	// Remove removes the request from the buffer.
	Remove(ctx context.Context, key string) error
}

ConcurrentBufferBackend wraps the Add and Remove methods.

type DistLocker ¶

type DistLocker interface {
	// Lock locks the locker.
	Lock(ctx context.Context) error
	// Unlock unlocks the previously successfully locked lock.
	Unlock(ctx context.Context) error
}

DistLocker is a context aware distributed locker (interface is similar to sync.Locker).

type FixedWindow ¶

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

FixedWindow implements a Fixed Window rate limiting algorithm.

Simple and memory efficient algorithm that does not need a distributed lock. However it may be lenient when there are many requests around the boundary between 2 adjacent windows.

func NewFixedWindow(capacity int64, rate time.Duration, fixedWindowIncrementer FixedWindowIncrementer, clock Clock) *FixedWindow

func (f *FixedWindow) Limit(ctx context.Context) (time.Duration, error)

type FixedWindowInMemory ¶

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

FixedWindowInMemory is an in-memory implementation of FixedWindowIncrementer.

func LocalFixedWindow(key string) *FixedWindowInMemory

func NewFixedWindowInMemory() *FixedWindowInMemory

func (f *FixedWindowInMemory) Increment(ctx context.Context, window time.Time, _ time.Duration) (int64, error)

type FixedWindowIncrementer ¶

type FixedWindowIncrementer interface {
	// Increment increments the request counter for the window and returns the counter value.
	// TTL is the time duration before the next window.
	Increment(ctx context.Context, window time.Time, ttl time.Duration) (int64, error)
}

FixedWindowIncrementer wraps the Increment method.

type FixedWindowRedis ¶

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

FixedWindowRedis implements FixedWindow in Redis.

func NewFixedWindowRedis(cli redis.UniversalClient, prefix string) *FixedWindowRedis

func (f *FixedWindowRedis) Increment(ctx context.Context, window time.Time, ttl time.Duration) (int64, error)

type LeakyBucket ¶

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

LeakyBucket implements the https://en.wikipedia.org/wiki/Leaky_bucket#As_a_queue algorithm.

func NewLeakyBucket(capacity int64, rate time.Duration, locker DistLocker, leakyBucketStateBackend LeakyBucketStateBackend, clock Clock, logger Logger) *LeakyBucket

func (t *LeakyBucket) Limit(ctx context.Context) (time.Duration, error)

type LeakyBucketInMemory ¶

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

LeakyBucketInMemory is an in-memory implementation of LeakyBucketStateBackend.

func LocalLeakyBucket(key string) *LeakyBucketInMemory

func NewLeakyBucketInMemory() *LeakyBucketInMemory

func (l *LeakyBucketInMemory) SetState(ctx context.Context, state LeakyBucketState) error

func (l *LeakyBucketInMemory) State(ctx context.Context) (LeakyBucketState, error)

type LeakyBucketRedis ¶

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

LeakyBucketRedis is a Redis implementation of a LeakyBucketStateBackend.

func NewLeakyBucketRedis(cli redis.UniversalClient, prefix string, ttl time.Duration, raceCheck bool) *LeakyBucketRedis

func (t *LeakyBucketRedis) SetState(ctx context.Context, state LeakyBucketState) error

func (t *LeakyBucketRedis) State(ctx context.Context) (LeakyBucketState, error)

type LeakyBucketState ¶

type LeakyBucketState struct {
	// Last is the Unix timestamp in nanoseconds of the most recent request.
	Last int64
}

LeakyBucketState represents the state of a LeakyBucket.

func (s LeakyBucketState) IzZero() bool

type LeakyBucketStateBackend ¶

type LeakyBucketStateBackend interface {
	// State gets the current state of the LeakyBucket.
	State(ctx context.Context) (LeakyBucketState, error)
	// SetState sets (persists) the current state of the LeakyBucket.
	SetState(ctx context.Context, state LeakyBucketState) error
}

LeakyBucketStateBackend interface encapsulates the logic of retrieving and persisting the state of a LeakyBucket.

type LockNoop ¶

type LockNoop struct {
}

LockNoop is a no-op implementation of the DistLocker interface. It should only be used with the in-memory backends as they are already thread-safe and don't need distributed locks.

func NewLockNoop() *LockNoop

func (n LockNoop) Lock(ctx context.Context) error

func (n LockNoop) Unlock(_ context.Context) error

type LockRedis ¶

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

LockRedis is a wrapper around github.com/go-redsync/redsync that implements the DistLocker interface.

func NewLockRedis(pool redsyncredis.Pool, mutexName string) *LockRedis

func (l *LockRedis) Lock(ctx context.Context) error

func (l *LockRedis) Unlock(ctx context.Context) error

type Logger ¶

type Logger interface {
	// Log logs the given arguments.
	Log(v ...interface{})
}

Logger wraps the Log method for logging.

type SlidingWindow ¶

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

SlidingWindow implements a Sliding Window rate limiting algorithm.

It does not require a distributed lock and uses a minimum amount of memory, however it will disallow all the requests in case when a client is flooding the service with requests. It's the client's responsibility to handle the disallowed request and wait before making a new request again.

func NewSlidingWindow(capacity int64, rate time.Duration, slidingWindowIncrementer SlidingWindowIncrementer, clock Clock, epsilon float64) *SlidingWindow

func (s *SlidingWindow) Limit(ctx context.Context) (time.Duration, error)

type SlidingWindowInMemory ¶

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

SlidingWindowInMemory is an in-memory implementation of SlidingWindowIncrementer.

func LocalSlidingWindow(key string) *SlidingWindowInMemory

func NewSlidingWindowInMemory() *SlidingWindowInMemory

func (s *SlidingWindowInMemory) Increment(ctx context.Context, prev, curr time.Time, _ time.Duration) (int64, int64, error)

type SlidingWindowIncrementer ¶

type SlidingWindowIncrementer interface {
	// Increment increments the request counter for the current window and returns the counter values for the previous
	// window and the current one.
	// TTL is the time duration before the next window.
	Increment(ctx context.Context, prev, curr time.Time, ttl time.Duration) (prevCount, currCount int64, err error)
}

SlidingWindowIncrementer wraps the Increment method.

type SlidingWindowRedis ¶

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

SlidingWindowRedis implements SlidingWindow in Redis.

func NewSlidingWindowRedis(cli redis.UniversalClient, prefix string) *SlidingWindowRedis

func (s *SlidingWindowRedis) Increment(ctx context.Context, prev, curr time.Time, ttl time.Duration) (int64, int64, error)

type StdLogger ¶

type StdLogger struct{}

StdLogger implements the Logger interface.

func NewStdLogger() *StdLogger

func (l *StdLogger) Log(v ...interface{})

type SystemClock ¶

type SystemClock struct {
}

SystemClock implements the Clock interface by using the real system clock.

func NewSystemClock() *SystemClock

func (c *SystemClock) Now() time.Time

type TokenBucket ¶

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

TokenBucket implements the https://en.wikipedia.org/wiki/Token_bucket algorithm.

func NewTokenBucket(capacity int64, refillRate time.Duration, locker DistLocker, tokenBucketStateBackend TokenBucketStateBackend, clock Clock, logger Logger) *TokenBucket

func (t *TokenBucket) Limit(ctx context.Context) (time.Duration, error)

func (t *TokenBucket) Take(ctx context.Context, tokens int64) (time.Duration, error)

type TokenBucketInMemory ¶

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

TokenBucketInMemory is an in-memory implementation of TokenBucketStateBackend.

The state is not shared nor persisted so it won't survive restarts or failures. Due to the local nature of the state the rate at which some endpoints are accessed can't be reliably predicted or limited.

Although it can be used as a global rate limiter with a round-robin load-balancer.

func LocalTokenBucket(key string) *TokenBucketInMemory

func NewTokenBucketInMemory() *TokenBucketInMemory

func (t *TokenBucketInMemory) SetState(ctx context.Context, state TokenBucketState) error

func (t *TokenBucketInMemory) State(ctx context.Context) (TokenBucketState, error)

type TokenBucketRedis ¶

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

TokenBucketRedis is a Redis implementation of a TokenBucketStateBackend.

Redis is an in-memory key-value data storage which also supports persistence. It is a better choice for high load cases than etcd as it does not keep old values of the keys thus does not need the compaction/defragmentation.

Although depending on a persistence and a cluster configuration some data might be lost in case of a failure resulting in an under-limiting the accesses to the service.

func NewTokenBucketRedis(cli redis.UniversalClient, prefix string, ttl time.Duration, raceCheck bool) *TokenBucketRedis

func (t *TokenBucketRedis) SetState(ctx context.Context, state TokenBucketState) error

func (t *TokenBucketRedis) State(ctx context.Context) (TokenBucketState, error)

type TokenBucketState ¶

type TokenBucketState struct {
	// Last is the last time the state was updated (Unix timestamp in nanoseconds).
	Last int64
	// Available is the number of available tokens in the bucket.
	Available int64
}

TokenBucketState represents a state of a token bucket.

type TokenBucketStateBackend ¶

type TokenBucketStateBackend interface {
	// State gets the current state of the TokenBucket.
	State(ctx context.Context) (TokenBucketState, error)
	// SetState sets (persists) the current state of the TokenBucket.
	SetState(ctx context.Context, state TokenBucketState) error
}

TokenBucketStateBackend interface encapsulates the logic of retrieving and persisting the state of a TokenBucket.