limits

Documentation

Index

• type AgentConfig
• type Agents
  • func ParseConfig(path string) (Agents, error)
• type Config
• type Cron
  • func NewCron(schedule string, duration time.Duration) *Cron
  • func (c *Cron) IsLimited(t time.Time) bool
• 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)

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.

func ParseConfig

func ParseConfig(path string) (Agents, error)

ParseConfig interprets the configuration file and returns the set of agent limits.

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 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.