In memory sliding window seems to be not honouring the limits

[dheerajjoshim]

I have very simple example of in memory sliding window. Limit is one call for a give key and duration is 10 seconds. It starts of with limiting one request but after 10th second two calls are being allowed.

import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;

import es.moki.ratelimitj.core.limiter.request.RequestLimitRule;
import es.moki.ratelimitj.core.limiter.request.RequestRateLimiter;
import es.moki.ratelimitj.inmemory.request.InMemorySlidingWindowRequestRateLimiter;

public class RateLimitExample {

    public static void main(final String... strings) {

        final Duration precisionDuration = Duration.of(1, ChronoUnit.SECONDS);

        // 1 request per 10 seconds if address is same
        final Duration addressDuration = Duration.of(10, ChronoUnit.SECONDS);
        final RequestLimitRule addressRule = RequestLimitRule.of(addressDuration, 1).withPrecision(precisionDuration);
        final RequestRateLimiter addressRuleRateLimiter = new InMemorySlidingWindowRequestRateLimiter(addressRule);

        while(true) {
            final UserObject user = UserObject.builder().age(11).name("ABC").address("NewYork").build();
            processStudent(user, addressRuleRateLimiter);
        }
    }

    private static void processStudent(final UserObject user, final RequestRateLimiter addressRuleRateLimiter) {
        if (!addressRuleRateLimiter.overLimitWhenIncremented(user.getAddress())) {
            user.callStudent();
        }
    }
}

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

import lombok.Builder;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
@EqualsAndHashCode
@Builder
public class UserObject {
    String name;
    int age;
    String address;
    boolean isProcessed;

    static DateFormat dateFormat = new SimpleDateFormat("dd MMM yyyy HH:mm:ss");

    public void callStudent() {
        Date currentDate = new Date(System.currentTimeMillis()); 
        System.out.println(dateFormat.format(currentDate)+"  "+this.toString());
    }
}

Output

10 Mar 2020 14:26:17  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:26:27  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:26:27  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:26:37  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:26:37  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:26:47  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:26:47  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:26:57  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:26:57  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:27:07  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 14:27:07  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)

As you can see first call for key NewYork was allowed only once for 10 seconds. But after that it allowed two calls.

Also how actively this library is maintained?

[dheerajjoshim]

This appears to be working just fine in the Redis environment

import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.Collections;
import java.util.Set;

import org.junit.Rule;
import org.junit.Test;
import org.testcontainers.containers.GenericContainer;

import es.moki.ratelimitj.core.limiter.request.RequestLimitRule;
import es.moki.ratelimitj.core.limiter.request.RequestRateLimiter;
import es.moki.ratelimitj.redis.request.RedisRateLimiterFactory;
import io.lettuce.core.RedisClient;

public class RedisTest {

    @Rule
    public GenericContainer<?> redis = new GenericContainer<>("redis:3.0.6").withExposedPorts(6379);

    @Test
    public void test() {
        final RedisRateLimiterFactory factory =
                new RedisRateLimiterFactory(
                        RedisClient.create("redis://" + redis.getContainerIpAddress() + ":"
                                + redis.getMappedPort(6379)));

        final Duration precisionDuration = Duration.of(1, ChronoUnit.SECONDS);

        final Set<RequestLimitRule> rules =
                Collections.singleton(RequestLimitRule.of(Duration.ofSeconds(10), 1)
                        .withPrecision(precisionDuration));
        final RequestRateLimiter requestRateLimiter = factory.getInstance(rules);

        while (true) {
            final UserObject user =
                    UserObject.builder().age(11).name("ABC").address("NewYork").build();
            processStudent(user, requestRateLimiter);
        }

    }

    private static void processStudent(final UserObject user,
            final RequestRateLimiter addressRuleRateLimiter) {
        if (!addressRuleRateLimiter.overLimitWhenIncremented(user.getAddress())) {
            user.callStudent();
        }
    }
}

Output

10 Mar 2020 17:00:36  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 17:00:46  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 17:00:56  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 17:01:06  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)
10 Mar 2020 17:01:16  UserObject(name=ABC, age=11, address=NewYork, isProcessed=false)

Used TestContainer to validate