Several customers have asked for support for basic composition with rate limiters, e.g. (limit1 AND limit2 AND limit3). Imagine a scenario where a service has an official rate limit of "10 per second, 100 per minute":

x = Sidekiq::Limiter.window(:svc_sec, 10, :second)
y = Sidekiq::Limiter.window(:svc_min, 100, :minute)

x.within_limit do
  y.within_limit do
    service.call ...
  end
end

There's a number of issues with this:

0. Every within_limit call increments a counter to track the limit. If x passes but y fails, we've incremented x unnecessarily.
1. Limiters are typically realtime-sensitive so things like the current bucket can change from millisecond to millisecond. x and y could use different buckets/windows/etc.
2. We don't want Lua executing a long chain of logic within Redis, leading to latency spikes.

I think the correct approach is for optimistic transactions: each limiter call will make a round trip to Redis and consume a token, but that call will return an object which can be used to rollback that consumption if a later limiter raises OverLimit. In the code above, if x passes ok but y raises OverLimit, we want to rollback the token consumed by x since we didn't actually make the call to the service.

Something like this:

Sidekiq::Limiter.within_all_limits(x, y) do
  service.call
end

# or

Sidekiq::Limiter.and(x, y) do
  service.call
end

Internally that API would maintain a list of rollback objects and roll back any earlier limits if a later limiter raises OverLimit. Is a simple AND(x, y) sufficient? Would we ever want OR(x, y)?

Ideas, comments and feedback welcome.