quotas

Documentation

Index

• func PerMember(service string, globalRPS, instanceRPS float64, resolver membership.Resolver) float64
• type Collection
  • func NewCollection(factory LimiterFactory) *Collection
  • func (c *Collection) For(key string) Limiter
• type DynamicRateLimiter
  • func NewDynamicRateLimiter(rps RPSFunc) *DynamicRateLimiter
  • func (d *DynamicRateLimiter) Allow() bool
  • func (d *DynamicRateLimiter) Reserve() *rate.Reservation
  • func (d *DynamicRateLimiter) Wait(ctx context.Context) error
• type Info
• type Limiter
• type LimiterFactory
  • func NewFallbackDynamicRateLimiterFactory(primary dynamicconfig.IntPropertyFnWithDomainFilter, ...) LimiterFactory
  • func NewPerMemberDynamicRateLimiterFactory(service string, globalRPS dynamicconfig.IntPropertyFnWithDomainFilter, ...) LimiterFactory
  • func NewSimpleDynamicRateLimiterFactory(rps dynamicconfig.IntPropertyFnWithDomainFilter) LimiterFactory
• type MultiStageRateLimiter
  • func NewMultiStageRateLimiter(global Limiter, domainLimiters *Collection) *MultiStageRateLimiter
  • func (d *MultiStageRateLimiter) Allow(info Info) bool
• type Policy
• type RPSFunc
• type RPSKeyFunc
• type RateLimiter
  • func NewRateLimiter(maxDispatchPerSecond *float64, ttl time.Duration, minBurst int) *RateLimiter
  • func NewSimpleRateLimiter(rps int) *RateLimiter
  • func (rl *RateLimiter) Allow() bool
  • func (rl *RateLimiter) Limit() float64
  • func (rl *RateLimiter) Reserve() *rate.Reservation
  • func (rl *RateLimiter) UpdateMaxDispatch(maxDispatchPerSecond *float64)
  • func (rl *RateLimiter) Wait(ctx context.Context) error

Functions

func PerMember

func PerMember(service string, globalRPS, instanceRPS float64, resolver membership.Resolver) float64

PerMember allows creating per instance RPS based on globalRPS averaged by member count for a given service. If member count can not be retrieved or globalRPS is not provided it falls back to instanceRPS.

Types

type Collection

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

Collection stores a map of limiters by key

func NewCollection

func NewCollection(factory LimiterFactory) *Collection

NewCollection create a new limiter collection. Given factory is called to create new individual limiter.

func (*Collection) For

func (c *Collection) For(key string) Limiter

For retrieves limiter by a given key. If limiter for such key does not exists, it creates new one with via factory.

type DynamicRateLimiter

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

DynamicRateLimiter implements a dynamic config wrapper around the rate limiter, checks for updates to the dynamic config and updates the rate limiter accordingly

func NewDynamicRateLimiter

func NewDynamicRateLimiter(rps RPSFunc) *DynamicRateLimiter

NewDynamicRateLimiter returns a rate limiter which handles dynamic config

func (*DynamicRateLimiter) Allow

func (d *DynamicRateLimiter) Allow() bool

Allow immediately returns with true or false indicating if a rate limit token is available or not

func (*DynamicRateLimiter) Reserve

func (d *DynamicRateLimiter) Reserve() *rate.Reservation

Reserve reserves a rate limit token

func (*DynamicRateLimiter) Wait

func (d *DynamicRateLimiter) Wait(ctx context.Context) error

Wait waits up till deadline for a rate limit token

type Info

type Info struct {
	Domain string
}

Info corresponds to information required to determine rate limits

type Limiter

type Limiter interface {
	// Allow attempts to allow a request to go through. The method returns
	// immediately with a true or false indicating if the request can make
	// progress
	Allow() bool

	// Wait waits till the deadline for a rate limit token to allow the request
	// to go through.
	Wait(ctx context.Context) error

	// Reserve reserves a rate limit token
	Reserve() *rate.Reservation
}

Limiter corresponds to basic rate limiting functionality.

type LimiterFactory

type LimiterFactory interface {
	// GetLimiter returns a new Limiter for the given domain
	GetLimiter(domain string) Limiter
}

LimiterFactory is used to create a Limiter for a given domain

func NewFallbackDynamicRateLimiterFactory

func NewFallbackDynamicRateLimiterFactory(
	primary dynamicconfig.IntPropertyFnWithDomainFilter,
	secondary dynamicconfig.IntPropertyFn,
) LimiterFactory

LimiterFactory is used to create a Limiter for a given domain the created Limiter will use the primary dynamic config if it is set otherwise it will use the secondary dynamic config

func NewPerMemberDynamicRateLimiterFactory

func NewPerMemberDynamicRateLimiterFactory(
	service string,
	globalRPS dynamicconfig.IntPropertyFnWithDomainFilter,
	instanceRPS dynamicconfig.IntPropertyFnWithDomainFilter,
	resolver membership.Resolver,
) LimiterFactory

NewPerMemberDynamicRateLimiterFactory creates a new LimiterFactory which creates a new DynamicRateLimiter for each domain, the RPS for the DynamicRateLimiter is given by the globalRPS and averaged by member count for a given service. instanceRPS is used as a fallback if globalRPS is not provided.

func NewSimpleDynamicRateLimiterFactory

func NewSimpleDynamicRateLimiterFactory(rps dynamicconfig.IntPropertyFnWithDomainFilter) LimiterFactory

NewSimpleDynamicRateLimiterFactory creates a new LimiterFactory which creates a new DynamicRateLimiter for each domain, the RPS for the DynamicRateLimiter is given by the dynamic config

type MultiStageRateLimiter

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

MultiStageRateLimiter indicates a domain specific rate limit policy

func NewMultiStageRateLimiter

func NewMultiStageRateLimiter(global Limiter, domainLimiters *Collection) *MultiStageRateLimiter

NewMultiStageRateLimiter returns a new domain quota rate limiter. This is about an order of magnitude slower than

func (*MultiStageRateLimiter) Allow

func (d *MultiStageRateLimiter) Allow(info Info) bool

Allow attempts to allow a request to go through. The method returns immediately with a true or false indicating if the request can make progress

type Policy

type Policy interface {
	// Allow attempts to allow a request to go through. The method returns
	// immediately with a true or false indicating if the request can make
	// progress
	Allow(info Info) bool
}

Policy corresponds to a quota policy. A policy allows implementing layered and more complex rate limiting functionality.

type RPSFunc

type RPSFunc func() float64

RPSFunc returns a float64 as the RPS

type RPSKeyFunc

type RPSKeyFunc func(key string) float64

RPSKeyFunc returns a float64 as the RPS for the given key

type RateLimiter

type RateLimiter struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

RateLimiter is a wrapper around the golang rate limiter handling dynamic configuration updates of the max dispatch per second. This has comparable performance to the token bucket rate limiter. BenchmarkSimpleRateLimiter-4 10000000 114 ns/op (tokenbucket) BenchmarkRateLimiter-4 10000000 148 ns/op (this)

func NewRateLimiter

func NewRateLimiter(maxDispatchPerSecond *float64, ttl time.Duration, minBurst int) *RateLimiter

NewRateLimiter returns a new rate limiter that can handle dynamic configuration updates

func NewSimpleRateLimiter

func NewSimpleRateLimiter(rps int) *RateLimiter

NewSimpleRateLimiter returns a new rate limiter backed by the golang rate limiter

func (*RateLimiter) Allow

func (rl *RateLimiter) Allow() bool

Allow immediately returns with true or false indicating if a rate limit token is available or not

func (*RateLimiter) Limit

func (rl *RateLimiter) Limit() float64

Limit returns the current rate per second limit for this ratelimiter

func (*RateLimiter) Reserve

func (rl *RateLimiter) Reserve() *rate.Reservation

Reserve reserves a rate limit token

func (*RateLimiter) UpdateMaxDispatch

func (rl *RateLimiter) UpdateMaxDispatch(maxDispatchPerSecond *float64)

UpdateMaxDispatch updates the max dispatch rate of the rate limiter

func (*RateLimiter) Wait

func (rl *RateLimiter) Wait(ctx context.Context) error

Wait waits up till deadline for a rate limit token