Request: ability to detect API rate limit hit, and re-attempt the request about go-binance HOT 7 CLOSED

Hi @Krisa , in my opinion, it's not a job of SDK, you should check the rate limit in your app using the SDK.

from go-binance.

It would be nice but should just allow custom rate limiters by implementing an interface. I use this lib in a distributed env and using redis for rate limiting.

from go-binance.

@adshao sorry, which SDK do you refer to?

Not sure we're referring to the same thing, but I'm not sure how this could possibly be implemented in a good way outside this package:
1- The current rate limit is returned in the HTTP headers as described in the Binance doc through X-MBX-USED-WEIGHT-(intervalNum)(intervalLetter) and I don't think there is a way to read this value outside the package. If there was an easy way to retrieve this value, it would be a good first step though.
2- Obviously I could catch errors when it's already too late, and implement for each different request a rate limiter as described in my OP. That looks completely sub-optimal though. I was instead thinking this shall be implemented somewhere in that function

from go-binance.

@Krisa SDK is this go-binance package.
Thanks for the advise, you are right, currently there is no way to get response instance, so that we can't check current rate limit which is returned in response header.
Maybe we can define a interface for all service data to implement, for example:

type Response struct {
    Header net.http.Header
}

then parse response header into Header field.
So that users can get the response header to check rate limit.
Is there any better advise?

from go-binance.

Ok, closing this issue as actually, this can be implemented as of now by using the RoundTripper and overriding the HTTPClient. For reference:
https://stackoverflow.com/questions/47465927/use-same-headers-for-every-request https://github.com/adshao/go-binance/blob/master/client.go#L137

from go-binance.

@0cv can you please provide an example how to use it with go-binance?

from go-binance.

@boskiv
Something like

var weightMaxPerMinute int
var usedWeight int

// transport binance transport client
type transport struct {
	UnderlyingTransport http.RoundTripper
}

// RoundTrip implement http roundtrip
func (t *transport) RoundTrip(req *http.Request) (*http.Response, error) {
	resp, err := t.UnderlyingTransport.RoundTrip(req)
	if resp != nil && resp.Header != nil {
		usedWeight, _ = strconv.Atoi(resp.Header.Get("X-Mbx-Used-Weight-1m"))
	}

	return resp, err
}

func init() {
        binanceClient = binance.NewClient(apiKey, secretKey)
	c := http.Client{Transport: &transport{UnderlyingTransport: http.DefaultTransport}}
	binanceClient.HTTPClient = &c
}

Then before every call to the API, you exec checkRateLimit

func checkRateLimit() {
	if usedWeight > weightMaxPerMinute {
		now := time.Now()
		time.Sleep(time.Until(now.Add(time.Duration(60-now.Second()) * time.Second)))
	}
}

But from my experience, maybe I was doing something wrong or something was not correct on Binance side, but the practical limits were not really the same as the theoretical limits (1200 per minute). It's a long time I've not used it, but I think I had something around 900 or 1000 for weightMaxPerMinute

from go-binance.