limits

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(schedule string, duration time.Duration) *Cron

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

type FullConfig ¶ added in v0.19.0

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 ¶ added in v0.17.4

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 ¶ added in v0.17.4

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 ¶ added in v0.17.0

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 ¶ added in v0.17.0

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(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 ¶ added in v0.19.0

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

TierLimitConfig holds the rate limit configuration for a single tier.

type TierLimits ¶ added in v0.19.0

type TierLimits map[int]LimitConfig

TierLimits maps tier numbers to their LimitConfig.