limiter

package
v3.7.0 Latest Latest
Warning

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

Go to latest
Published: Nov 9, 2026 License: MIT Imports: 17 Imported by: 54

Documentation

Index

Constants

This section is empty.

Variables

View Source
var ConfigDefault = Config{
	Max:        defaultLimiterMax,
	Expiration: 1 * time.Minute,

	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 {
	// Storage 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. It runs before MaxFunc.
	//
	// Optional. Default: nil
	Next func(c fiber.Ctx) bool

	// A function to dynamically calculate the max requests supported by the rate limiter middleware.
	// Returning 0 skips the limiter for the request; a negative value rejects every request.
	//
	// Default: func(c fiber.Ctx) int {
	//   return cfg.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.
	//
	// A key's window keeps the length given by the request that opened it.
	//
	// 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.
	// A handler error that is not a *fiber.Error counts as a 500 unless it set an error status.
	//
	// Default: false
	SkipFailedRequests bool

	// When set to true, requests with StatusCode < 400 won't be counted.
	// A handler error that is not a *fiber.Error counts as a 500 unless it set an error status.
	//
	// 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.
	// A key longer than 192 bytes is shown as its SHA-256 digest.
	//
	// 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. Unset fields of cfg take their defaults.

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. Unset fields of cfg take their defaults.

Jump to

Keyboard shortcuts

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