Help us shape the future of Go! Take the 2026 Go Developer Survey

limiter

package
v3.6.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 14, 2026 License: MIT Imports: 15 Imported by: 54

Documentation

Index

Constants

This section is empty.

Variables

View Source
var ConfigDefault = Config{
	Max:        defaultLimiterMax,
	Expiration: 1 * time.Minute,
	MaxFunc: func(_ fiber.Ctx) int {
		return defaultLimiterMax
	},

	KeyGenerator: func(c fiber.Ctx) string {
		return c.IP()
	},
	LimitReached: func(c fiber.Ctx) error {
		return c.SendStatus(fiber.StatusTooManyRequests)
	},
	SkipFailedRequests:     false,
	SkipSuccessfulRequests: false,
	DisableHeaders:         false,
	DisableValueRedaction:  false,
	LimiterMiddleware:      FixedWindow{},
}

ConfigDefault is the default config

Functions

func New

func New(config ...Config) fiber.Handler

New creates a new middleware handler

Types

type Config

type Config struct {
	// Store is used to store the state of the middleware
	//
	// Default: an in memory store for this process only
	Storage fiber.Storage

	// LimiterMiddleware is the struct that implements a limiter middleware.
	//
	// Default: a new Fixed Window Rate Limiter
	LimiterMiddleware Handler
	// Next defines a function to skip this middleware when returned true.
	//
	// Optional. Default: nil
	Next func(c fiber.Ctx) bool

	// A function to dynamically calculate the max requests supported by the rate limiter middleware
	//
	// Default: func(c fiber.Ctx) int {
	//   return c.Max
	// }
	MaxFunc func(c fiber.Ctx) int

	// A function to dynamically calculate the expiration time for rate limiter entries.
	// Window accounting is whole-second, so a positive value below one second is floored to
	// one second. A zero or negative value falls back to the configured Expiration.
	//
	// Default: A function that returns the static `Expiration` value from the config.
	ExpirationFunc func(c fiber.Ctx) time.Duration

	// KeyGenerator allows you to generate custom keys, by default c.IP() is used.
	// Behind a reverse proxy, c.IP() only identifies a client when TrustProxy,
	// TrustProxyConfig and ProxyHeader are configured, plus EnableIPValidation when
	// the header is a chain the proxy appends to (X-Forwarded-For); otherwise it is
	// the proxy's address or the raw, client-influenced forwarded header.
	//
	// Default: func(c fiber.Ctx) string {
	//   return c.IP()
	// }
	KeyGenerator func(fiber.Ctx) string

	// LimitReached is called when a request hits the limit
	//
	// Default: func(c fiber.Ctx) error {
	//   return c.SendStatus(fiber.StatusTooManyRequests)
	// }
	LimitReached fiber.Handler

	// Max number of recent connections during `Expiration` seconds before sending a 429 response
	//
	// Default: 5
	Max int

	// Expiration is the time on how long to keep records of requests in memory
	//
	// Default: 1 * time.Minute
	Expiration time.Duration

	// When set to true, requests with StatusCode >= 400 won't be counted.
	//
	// Default: false
	SkipFailedRequests bool

	// When set to true, requests with StatusCode < 400 won't be counted.
	//
	// Default: false
	SkipSuccessfulRequests bool

	// When set to true, the middleware will not include the rate limit headers (X-RateLimit-* and Retry-After) in the response.
	//
	// Default: false
	DisableHeaders bool

	// DisableValueRedaction turns off masking limiter keys in logs and error messages when set to true.
	//
	// Default: false
	DisableValueRedaction bool
	// contains filtered or unexported fields
}

Config defines the config for middleware.

type FixedWindow

type FixedWindow struct{}

FixedWindow implements a fixed-window rate limiting strategy.

func (FixedWindow) New

func (FixedWindow) New(cfg *Config) fiber.Handler

New creates a new fixed window middleware handler

type Handler

type Handler interface {
	New(config *Config) fiber.Handler
}

Handler defines a rate-limiting strategy that can produce a middleware handler using the provided configuration.

type SlidingWindow

type SlidingWindow struct{}

SlidingWindow implements the sliding-window rate limiting strategy.

func (SlidingWindow) New

func (SlidingWindow) New(cfg *Config) fiber.Handler

New creates a new sliding window middleware handler

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL