Question for rate limiter

[gigimushroom]

I am trying to set up rate limiter for my grpc:
limit := rate.NewLimiter(rate.Every(time.Minute), 10)
e = ratelimit.NewErroringLimiter(limit)(e)
pb.RegisterFlowServer(s, server.NewBinding(e))
...

My client test code is to send 10 RPC, wait a minute, then send another 10 RPC.

However, my 2nd batch failed 9 out of 10.

Any ideas?

[gigimushroom]

It seems the token need a long time to refill itself.

func TestXRateErroring(t *testing.T) {
	limit := rate.NewLimiter(rate.Every(time.Second), 2)
	testSuccessThenFailure(
		t,
		ratelimit.NewErroringLimiter(limit)(nopEndpoint),
		ratelimit.ErrLimited.Error())
}

func testSuccessThenFailure(t *testing.T, e endpoint.Endpoint, failContains string) {
	ctx, cxl := context.WithTimeout(context.Background(), 5*time.Second)
	defer cxl()

	// First request should succeed.
	if _, err := e(ctx, struct{}{}); err != nil {
		t.Errorf("unexpected: %v\n", err)
	}
	if _, err := e(ctx, struct{}{}); err != nil {
		t.Errorf("unexpected2: %v\n", err)
	}

	time.Sleep(time.Second * 2)

	if _, err := e(ctx, struct{}{}); err != nil {
		t.Errorf("unexpected3: %v\n", err)
	}

	if _, err := e(ctx, struct{}{}); err != nil {
		t.Errorf("unexpected5: %v\n", err)
	}
}

Result:

=== RUN   TestXRateErroring
2018-04-04 23:57:04.005158994 -0700 PDT m=+0.000303523 0001-01-01 00:00:00 +0000 UTC 2
num of burst left 2 num of tokens 1
2018-04-04 23:57:04.005276645 -0700 PDT m=+0.000421178 2018-04-04 23:57:04.005158994 -0700 PDT m=+0.000303523 1.000117655
num of burst left 2 num of tokens 0.00011765499999993878
2018-04-04 23:57:06.005817534 -0700 PDT m=+2.000962157 2018-04-04 23:57:04.005276645 -0700 PDT m=+0.000421178 2
num of burst left 2 num of tokens 1
2018-04-04 23:57:06.005983106 -0700 PDT m=+2.001127703 2018-04-04 23:57:06.005817534 -0700 PDT m=+2.000962157 1.000165546
num of burst left 2 num of tokens 0.0001655460000000719
--- PASS: TestXRateErroring (2.00s)
PASS
ok      intent/flow2.0/tools/rate       2.003s

I seems I need to make my program sleep 2 sec, so it will refill.
But based on the API:
rate.NewLimiter(rate.Every(time.Second), 2)
I thought it refill every second with max 2 burst.

Any ideas?

[gigimushroom]

Not a problem actually.

// A Limiter controls how frequently events are allowed to happen.
// It implements a "token bucket" of size b, initially full and refilled
// at rate r tokens per second.

// Every converts a minimum time interval between events to a Limit.
func Every(interval time.Duration) Limit {
if interval <= 0 {
return Inf
}
return 1 / Limit(interval.Seconds())
}
this produce r.

If I have rate.NewLimiter(rate.Every(time.Second * 1/3), 2),
then 1/3 sec is r = 3, so it generates 3 tokens per second!