effective rate limiting

I’m finding that I’m exceeding rate limits occasionally. Has anyone got an effective way of dealing with them?

I see there s a nice little RateLimiter class in guava. But i think to use it properly it has to be baked in at the lowest level where the RestProxyFactory is invoked. It needs to be applied at the request level, and shared across the AccountService, TradeService and MarketDataService. Wrapping the services in another rate limiting proxy might work. Something like this:

  protected TheRockAccountServiceRaw(Exchange exchange) {
    super(exchange);

    ExchangeSpecification spec = exchange.getExchangeSpecification();
    this.apiKey = spec.getApiKey();
    this.signatureCreator = new TheRockDigest(spec.getSecretKey());

    TheRockAuthenticated theApi = RestProxyFactory.createProxy(TheRockAuthenticated.class, spec.getSslUri());

    RateLimiter rateLimiter = spec.rateLimiter();

    if(rateLimiter != null) {
      this.theRockAuthenticated = rateLimit(theApi, rateLimiter, TheRockAuthenticated.class);
    } else {
      this.theRockAuthenticated = theApi;
    }
  }

  private static <API> API rateLimit(API theApi, RateLimiter rateLimiter, Class<API> theClass) {
    return (API) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{theClass}, new InvocationHandler() {

      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        rateLimiter.acquire();

        return method.invoke(theApi, args);
      }
    });
  }
    ...

@timmolter thoughts?

[timmolter]

Yeah, you’re right. I can see integrating something like this into RESCU in a way similar to the nonce factory, where different exchanges have different implementations of rate limiting logic. @mmazi what do you think?

[npomfret]

A reason to do it at this base level (once an appropriate model is in place) is that some implementations make multiple API calls for a single high level method call. So putting your rate limiter in your application won’t work as effectively.