limits

Documentation

Index

• func ParseFullConfig(path string) (Agents, TierLimits, error)
• type AgentConfig
• type Agents
• type Config
• type Cron
  • func NewCron(schedule string, duration time.Duration) *Cron
  • func (c *Cron) IsLimited(t time.Time) bool
• type FullConfig
• type LimitConfig
• type LimitStatus
• type RateLimitConfig
• type RateLimiter
  • func NewRateLimiter(pool *redis.Pool, config RateLimitConfig) *RateLimiter
  • func (rl *RateLimiter) IsLimited(ip, ua string) (LimitStatus, error)
  • func (rl *RateLimiter) IsLimitedWithTier(org, ip string, tierConfig LimitConfig) (LimitStatus, error)
• type TierLimitConfig
• type TierLimits

Functions

func ParseFullConfig

func ParseFullConfig(path string) (Agents, TierLimits, error)

ParseFullConfig interprets the configuration file and returns both agent limits and tier limits.

Types

type AgentConfig

type AgentConfig struct {
	Agent    string        `yaml:"agent"`
	Schedule string        `yaml:"schedule"`
	Duration time.Duration `yaml:"duration"`
}

AgentConfig holds the limit configuration for a user agent.

type Agents

type Agents map[string]*Cron

Agents holds the cron limits for a set of user agents.

type Config

type Config []AgentConfig

Config holds the limit configuration for all user agents.

type Cron

type Cron struct {
	*cronexpr.Expression
	// contains filtered or unexported fields
}

Cron infers time limits based on a cron schedule.

func NewCron

func NewCron(schedule string, duration time.Duration) *Cron

NewCron returns a new instance of Cron.

func (*Cron) IsLimited

func (c *Cron) IsLimited(t time.Time) bool

IsLimited returns whether the input time is within a time-limited window [start, end).

type FullConfig

type FullConfig struct {
	Agents []AgentConfig           `yaml:"agents"`
	Tiers  map[int]TierLimitConfig `yaml:"tiers"`
}

FullConfig holds the complete limit configuration including both agent-based and tier-based limits.

type LimitConfig

type LimitConfig struct {
	// Interval defines the duration of the sliding window
	Interval time.Duration

	// MaxEvents defines the maximum number of events allowed in the interval
	MaxEvents int
}

LimitConfig holds the configuration for a single rate limit type

type LimitStatus

type LimitStatus struct {
	// IsLimited indicates if the request should be rate limited
	IsLimited bool
	// LimitType indicates which limit was exceeded ("ip" or "ipua" or "")
	LimitType string
}

LimitStatus indicates the result of a rate limit check

type RateLimitConfig

type RateLimitConfig struct {
	// IPConfig defines the rate limiting configuration for IP-only checks
	IPConfig LimitConfig

	// IPUAConfig defines the rate limiting configuration for IP+UA checks
	IPUAConfig LimitConfig

	// KeyPrefix is the prefix for Redis keys
	KeyPrefix string
}

RateLimitConfig holds the configuration for both IP-only and IP+UA rate limiting.

type RateLimiter

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

RateLimiter implements a distributed rate limiter using Redis sorted sets (ZSET). It maintains sliding windows for both IP-only and IP+UA combinations, where:

• Each event is stored in a ZSET with the timestamp as score
• Old events (outside the window) are automatically removed
• Keys automatically expire after the configured interval

The limiter considers a request to be rate-limited if the number of events in either window exceeds their respective MaxEvents.

func NewRateLimiter

func NewRateLimiter(pool *redis.Pool, config RateLimitConfig) *RateLimiter

NewRateLimiter creates a new rate limiter.

func (*RateLimiter) IsLimited

func (rl *RateLimiter) IsLimited(ip, ua string) (LimitStatus, error)

IsLimited checks if the given IP and User-Agent combination should be rate limited. It first checks the IP-only limit, then the IP+UA limit if the IP-only check passes.

func (*RateLimiter) IsLimitedWithTier

func (rl *RateLimiter) IsLimitedWithTier(org, ip string, tierConfig LimitConfig) (LimitStatus, error)

IsLimitedWithTier checks if the given organization+IP combination should be rate limited based on the tier-specific configuration. This is used for /v2/priority/nearest endpoint where different tiers have different rate limits.

type TierLimitConfig

type TierLimitConfig struct {
	Interval  string `yaml:"interval"`
	MaxEvents int    `yaml:"max_events"`
}

TierLimitConfig holds the rate limit configuration for a single tier.

type TierLimits

type TierLimits map[int]LimitConfig

TierLimits maps tier numbers to their LimitConfig.