golang rate limit per minute

How to rate limit 20 requests per minute?

import "golang.org/x/time/rate"

limiter := rate.NewLimiter(rate.Every(1*time.Minute), 20)

for {
    limiter.Wait()
    //more code
}

This does not work. What that does is, it allows first 20 requests, then only allows 1 request per minute. What is expected is 20 requests on the first minute(Need not be evenly spread like 1 per 3 seconds) and then 20 more requests on the second minute. At any 1 minute interval, there cannot be more than 20 requests sent.

My solution: https://stackoverflow.com/a/72452542

Set the rate you expect :

limiter := rate.NewLimiter(rate.Every(1*time.Minute/20), 20)

for {
    limiter.Wait()
    //more code
}

playground: https://go.dev/play/p/ZpxpHj0vK7P

You seem to look for something that allows "bursts of up to 20, reset every minute". Here is a go at it :

type Limiter struct {
	maxCount int
	count    int
	ticker   *time.Ticker
	ch       chan struct{}
}

func (l *Limiter) run() {
	for {
		// if counter has reached 0: block until next tick
		if l.count <= 0 {
			<-l.ticker.C
			l.count = l.maxCount
		}

		// otherwise:
        // decrement 'count' each time a message is sent on channel,
        // reset 'count' to 'maxCount' when ticker says so
		select {
		case l.ch <- struct{}{}:
			l.count--

		case <-l.ticker.C:
			l.count = l.maxCount
		}
	}
}

func (l *Limiter) Wait() {
	<-l.ch
}

func NewLimiter(d time.Duration, count int) *Limiter {
	l := &Limiter{
		maxCount: count,
		count:    count,
		ticker:   time.NewTicker(d),
		ch:       make(chan struct{}),
	}
	go l.run()

	return l
}

https://go.dev/play/p/5WiOJL5nqCy

you can use time.Tick and for-select like this:

package main

import (
	"fmt"
	"time"
)

func main() {
	max := 20

	limiter := time.Tick(1 * time.Minute)

	exit := make(chan struct{})

	go func() {
		count := 0
		exit2 := 0
		defer func() {
			exit <- struct{}{}
		}()
		for {
			select {
			case <-limiter:
				count = 0
				fmt.Println("exit2: ", exit2)
				if exit2 == 3 {
					return
				}
				exit2++
			default:
				if count == max {
					continue
				}
				fmt.Println("accepting request", count)
				count++
			}
		}
	}()

	<-exit
}

try this

import (
	"fmt"
	"time"
)

func main() {
	limiter := time.Tick(3 * time.Minute) //changed from 20 to 3 because i realized you wanted 20 requests per minute, not 1 request per 20 minutes

	for true {
		<-limiter
		fmt.Println(time.Now())
	}
}

I haven't actually tried with 20 * time.Minute as the value, but I tried 200 * time.Milisecond and it worked. Here was my response

2022-05-31 00:06:13.447108 -0600 MDT m=+0.200889915
2022-05-31 00:06:13.651373 -0600 MDT m=+0.405148283
2022-05-31 00:06:13.851522 -0600 MDT m=+0.605291066
2022-05-31 00:06:14.051481 -0600 MDT m=+0.805244205
2022-05-31 00:06:14.250144 -0600 MDT m=+1.003900790
2022-05-31 00:06:14.450952 -0600 MDT m=+1.204703429
2022-05-31 00:06:14.648365 -0600 MDT m=+1.402110595
2022-05-31 00:06:14.848223 -0600 MDT m=+1.601961982
2022-05-31 00:06:15.04909 -0600 MDT m=+1.802823232
2022-05-31 00:06:15.250164 -0600 MDT m=+2.003891217

My solution

import (
        "sync"
        "time"
)

type Limiter interface {
        Wait()
}

type limiter struct {
        tick    time.Duration
        count   uint
        entries []time.Time
        index   uint
        mutex   sync.Mutex
}

func NewLimiter(tick time.Duration, count uint) Limiter {
        l := limiter{
                tick:  tick,
                count: count,
                index: 0,
        }
        l.entries = make([]time.Time, count)
        before := time.Now().Add(-2 * tick)
        for i, _ := range l.entries {
                l.entries[i] = before
        }
        return &l
}
func (l *limiter) Wait() {
        l.mutex.Lock()
        defer l.mutex.Unlock()
        last := &l.entries[l.index]
        next := last.Add(l.tick)
        now := time.Now()
        if now.Before(next) {
                time.Sleep(next.Sub(now))
        }
        *last = time.Now()
        l.index = l.index + 1
        if l.index == l.count {
                l.index = 0
        }
}