would it be possible to enhance Bucket interface (or at least GridBucket impl) to add a method that tries (no waiting) to consume up to N tokens at once and returns:

1. number of tokens actually consumed AND
2. the expiration date associated with these tokens. Thanks I can explain my use case if needed. Greg

In opposite to smooth refill which adds token as soon as possible, interval refill should regenerate tokens periodically.

Proposed API:

public static Refill fixedInterval(long tokens, Duration period) {
    // ...
}

public static Refill fixedInterval(Instant timeOfFirstRefill, long tokens, Duration period) {
     // ...
}

Hi,

I am creating Bucket in Single Hazelcast instance serving two Application data centers (DC) and having custom waiting code to consumer the token as follows.

Creation:

Bandwidth limit = Bandwidth.classic(bucketSize, Refill.intervally(bucketSize, period));
Bucket bucket = Bucket4j.extension(Hazelcast.class).builder().addLimit(limit)
					.build(hazelCastService.getBucketMap(), bucketId, RecoveryStrategy.RECONSTRUCT);

Consumption:

while (true) {
	probe = getBucket().tryConsumeAndReturnRemaining(bucketBean.getTokenSize());
	if (probe.isConsumed()) {
		break;
	} else {
		Thread.sleep((long) (probe.getNanosToWaitForRefill() / 1000000.0));
	}
}

But the issue is first data centers consumes token faster like three times higher than other one. So there is no equal distribution of tokens.

When application threads from both DCs sleeps till the refill and wakes-up, threads from first DC consumes faster than other one.

I am thinking it might be because custom handling of sleep and consume. Is this can be solved using "bucket.tryConsume(1, MAX_WAIT_NANOS, BlockingStrategy.PARKING)", so that I dont need to handle sleep. And token might being served in the order when thread arrives.

Please suggest if this works..

When it is, then I am not finding method from Bucket object, its part of BlockingBucket object, but I cannot able to instantiate that object. please help.

I have upgraded my Hazelcast and bucket 4j. And now I have error com.hazelcast.nio.serialization.HazelcastSerializationException: java.lang.ClassNotFoundException: io.github.bucket4j.grid.CommandResult

What is strange - this error happens only when I run my application on Kubernetes. When I run it on virtual machine or on my latop everything works OK

My application is using Spring Boot 2.2.1 and Spring Cloud Gateway and react

What I am doing wrong ?

My gradle dependencies

  implementation "com.github.vladimir-bukhtoyarov:bucket4j-core:6.2.0"
   implementation "com.github.vladimir-bukhtoyarov:bucket4j-jcache:6.2.0"
   implementation "com.github.vladimir-bukhtoyarov:bucket4j-hazelcast:6.2.0"
   implementation "javax.cache:cache-api:1.0.0"
   implementation "com.hazelcast:hazelcast:4.2"
   implementation "com.hazelcast:hazelcast-eureka-one:2.0.1"

My Hazelcast configuration code

 ```
    Config config = new Config();
   config.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(true);
        config.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
        config.getNetworkConfig().getJoin().getAwsConfig().setEnabled(false);
        config.getNetworkConfig().getJoin().getEurekaConfig().setEnabled(false);
        config.getNetworkConfig().getJoin().getKubernetesConfig().setEnabled(false);

        if (eurekaClientOption.isPresent()) {
            EurekaClient eurekaClient = eurekaClientOption.get();
            String appName = eurekaClient.getApplicationInfoManager().getEurekaInstanceConfig().getAppname();
            logger.info("hazelcast appName :" + appName);
            Application application = eurekaClient.getApplication(appName);
            if (application != null) {
                application.getInstancesAsIsFromEureka().forEach(
                        instanceInfo -> {
                            config.getNetworkConfig().getJoin().getTcpIpConfig().addMember(instanceInfo.getIPAddr() + ":" + port);
                            logger.info("hazelcast TcpIpConfig : {}",config.getNetworkConfig().getJoin().getTcpIpConfig());
                        }
                );
            } else {
                logger.error("hazelcast empty eureka application [{}]",appName);
            }
        } else {
            logger.error("hazelcast empty eurekaClient");
        }
        config.getNetworkConfig().setPort(port).setPortAutoIncrement(false);
        config.setLiteMember(false);
        logger.info("hazelcast config {}",config);
    config.setProperty("hazelcast.phone.home.enabled", "false");
    config.setProperty("hazelcast.initial.min.cluster.size","1");
    config.setProperty("hazelcast.socket.server.bind.any", "false");
   HazelcastInstance hazelcastInstance = new HazelcastInstanceFactory(config).getHazelcastInstance();

My bucket4j code

    ```
    if (hazelcastInstance != null) {
            IMap map = hazelcastInstance.getMap("bucket");
            int initialCapacity = (throttlingRule.getBandwith() + throttlingRule.getOverdraftBandwith());
            this.bucket = Bucket4j.extension(Hazelcast.class)
                    .builder()
                    .addLimit(Bandwidth.classic(initialCapacity, Refill.smooth(throttlingRule.getBandwith(), Duration.of(throttlingRule.getDuration(), throttlingRule.getDurationUnit()))))
                    .build(map, key, RecoveryStrategy.RECONSTRUCT);

            VerboseResult<EstimationProbe> verboseResult = bucket.asVerbose().estimateAbilityToConsume(1);
            BucketConfiguration bucketConfiguration = verboseResult.getConfiguration();
            logger.info("bucket for rule [{}] and key [{}] configuration [{}] availableTokens [{}]",throttlingRule,key,bucketConfiguration,bucket.getAvailableTokens());
        } else  {
            logger.warn("hazelcastInstance == null");
        }

  public ConsumptionProbe throttleProbe() {
       assert bucket != null;
       CompletableFuture<ConsumptionProbe> probe = bucket.asAsync().tryConsumeAndReturnRemaining(1);
       return probe.join();
   }

Exception

j.l.ClassNotFoundException: io.github.bucket4j.grid.CommandResult
	at j.i.l.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:581)
	at j.i.l.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
	at j.lang.ClassLoader.loadClass(ClassLoader.java:522)
	at c.h.i.n.ClassLoaderUtil.tryLoadClass(ClassLoaderUtil.java:289)
	at c.h.i.n.ClassLoaderUtil.loadClass(ClassLoaderUtil.java:249)
	at c.h.i.n.IOUtil$ClassLoaderAwareObjectInputStream.resolveClass(IOUtil.java:910)
	at j.i.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1995)
	at j.i.ObjectInputStream.readClassDesc(ObjectInputStream.java:1862)
	at j.i.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2169)
	at j.i.ObjectInputStream.readObject0(ObjectInputStream.java:1679)
	at j.i.ObjectInputStream.readObject(ObjectInputStream.java:493)
	at j.i.ObjectInputStream.readObject(ObjectInputStream.java:451)
	at c.h.i.s.i.d.JavaDefaultSerializers$JavaSerializer.read(JavaDefaultSerializers.java:86)
	... 11 common frames omitted
Wrapped by: c.h.n.s.HazelcastSerializationException: java.lang.ClassNotFoundException: io.github.bucket4j.grid.CommandResult
	at c.h.i.s.i.d.JavaDefaultSerializers$JavaSerializer.read(JavaDefaultSerializers.java:90)
	at c.h.i.s.i.d.JavaDefaultSerializers$JavaSerializer.read(JavaDefaultSerializers.java:79)
	at c.h.i.s.i.StreamSerializerAdapter.read(StreamSerializerAdapter.java:44)
	at c.h.i.s.i.AbstractSerializationService.toObject(AbstractSerializationService.java:208)
	at c.h.s.i.DelegatingCompletableFuture$DeserializingFunction.apply(DelegatingCompletableFuture.java:518)
	at c.h.s.i.AbstractInvocationFuture.lambda$unblockCompose$5(AbstractInvocationFuture.java:953)
	at j.u.c.ForkJoinTask$RunnableExecuteAction.exec(ForkJoinTask.java:1426)
	at j.u.c.ForkJoinTask.doExec(ForkJoinTask.java:290)
	at j.u.c.ForkJoinPool$WorkQueue.topLevelExec(ForkJoinPool.java:1020)
	at j.u.c.ForkJoinPool.scan(ForkJoinPool.java:1656)
	at j.u.c.ForkJoinPool.runWorker(ForkJoinPool.java:1594)
	at j.u.c.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:183)
Wrapped by: j.u.c.CompletionException: com.hazelcast.nio.serialization.HazelcastSerializationException: java.lang.ClassNotFoundException: io.github.bucket4j.grid.CommandResult
	at j.u.c.CompletableFuture.encodeThrowable(CompletableFuture.java:331)
	at j.u.c.CompletableFuture.completeThrowable(CompletableFuture.java:346)
	at j.u.c.CompletableFuture$UniApply.tryFire(CompletableFuture.java:632)
	at j.u.c.CompletableFuture.unipush(CompletableFuture.java:589)
	at j.u.c.CompletableFuture.uniApplyStage(CompletableFuture.java:660)
	at j.u.c.CompletableFuture.thenApplyAsync(CompletableFuture.java:2104)
	at c.h.s.i.InternalCompletableFuture.thenApply(InternalCompletableFuture.java:78)
	at i.g.b.AbstractBucket$1.tryConsumeAndReturnRemaining(AbstractBucket.java:147)
	at p.b.g.t.ThrottlingRuleBucket.throttleProbe(ThrottlingRuleBucket.java:64)

I set rate limit 5 request / 1 min

but sometime I can sent request over maximum rate.

I log available tokens of bucket and I look something wrong. Sometime (I wait 5 sec before 1 request) when pass 30sec avaliable token reset to 5 request but I fix

Refill.intervally(5, Duration.ofSeconds(60)) (wait for timeout reset avaliable token)
Bandwidth.classic(5,Refill.intervally(5, Duration.ofSeconds(60)))

Issue is how can I fix this issue because avaliable token of bucket should be reset when pass 1 min.

I use bucket-core and bucket4j-jcache version 4.0.1

This is some part of my log. I start first request is 15:11:39 avaliable is 5 and the last request is 15.12.08 (pass after first request 29 sec) but avaliable token is 5.

RateLimitingFilter  : available: 5 time: 15:11:39.563
RateLimitingFilter  : ########################################
RateLimitingFilter  : available: 4 time: 15:11:46.840
RateLimitingFilter  : ########################################
RateLimitingFilter  : available: 3 time: 15:11:53.820
RateLimitingFilter  : ########################################
RateLimitingFilter  : available: 2 time: 15:12:01.482
RateLimitingFilter  : ########################################
RateLimitingFilter  : available: 5 time: 15:12:08.235
RateLimitingFilter  : ########################################

Following points should be exposed:

• Token consumption.
• Token rejection.
• Amount of time spent in waiting to bucket refill.
• Count of InterruptedExceptions happens during waiting.

Design considerations:

• Monitoring must be pluggable, most likely statistic should be implemented as listener with methods onConsumed, onRejected, onWait, onInterrupt, it should be responsibility of client to decide how to this data should be accumulated, aggregated and exposed.
• Reference implementation on top of Dropwizard-Metrics should be provided.

Also it is need to support requqirements from #7

Hi Vladimir,

We are using bucket4j component for one of our API to throttle the request. The API that we wanted to throttle is running on 1 unix servers with 2 JVMs When we have done a performance testing after enabling the throttling with bucket4j, we observed that the tokens are not being managed properly.

Ex: We have created a bucket with 50 tokens, and ran a performance test with Jmeter with 100 concurrent users and we see that more than 50 requests were served. Here the expected behavior it should serve only 50 requests as we have only 50 tokens on the bucket.

Also, We want to achieve the below scenario, is it possible through Bucket4j?

Assume, our Server is able to handle 1000 requests per minute. We have 2 partners to consume our API, so we have created 2 buckets with each 500 tokens. But, we would like to handle only 50 active concurrent threads/requests at a time even though we have enough tokens in that bucket.

We are using Redis as a db for managing the tokens and below maven dependencies

Thank you in advance for your help. Could you please respond to this ASAP.

Regards, Sudhakar

I'm currently working on https://github.com/jhipster/generator-jhipster/issues/5388

So basically I'm doing a request filter like here in the documentation, but using JCache with Hazelcast like here in the documentation.

Mixing those 2 examples, my current implementation is the following (please note this is a Zuul filter, not a Servlet filter, but this doesn't make any difference):

String bucketId = getId(RequestContext.getCurrentContext().getRequest());
        
Bucket bucket = Bucket4j.jCacheBuilder(RecoveryStrategy.RECONSTRUCT)
    .addLimit(Bandwidth.simple(jHipsterProperties.getGateway().getRateLimiting().getLimit(),
        Duration.ofSeconds(3_600))
    .build(cache, bucketId);

if (bucket.tryConsumeSingleToken()) {
    // the limit is not exceeded
    log.debug("API rate limit OK for {}", bucketId);
} else {
    // limit is exceeded
    log.info("API rate limit exceeded for {}", bucketId);
    apiLimitExceeded();
}
return null;

This code works, and follows the documentation, but it worries me that we "create" a new Bucket for each HTTP request. This looks rather heavy, and I'd better re-use the Bucket that was created.

However, we just store a BucketState in the cache, and I can't find a way to get a Bucket out of the cache.

Am I doing something wrong? I currently think the API should be modified, or maybe better documented, because I can't find a good solution here.

We're keen to use the interval buckets (instead of greedy buckets), but would like the refill to happen on an interval boundary (i.e. start of second, minute, hour, day) rather than when the bucket is created.

The main reason for this, is to provide transparency to the end customer on when buckets are refilled.

For example:

• If we setup a bucket with 100 tokens that has a interval refill of 100 tokens every hour.
• Currently, if bucket is created 20 minutes past the hour, then it will get refilled 20 minutes past the next hour.
• If we were to create another bucket with same values but X minutes past the hour, then this would be refilled X minutes past the hour.

This is very confusing to customers, especially when they are testing the bucket4j behaviour.

A useful feature would be that when a bucket is created, there is an option that specifies that it should be refilled on the next interval boundary.

The intervals could be applied to second(?), minute, hour or day, and would need to accurate to at least 10ms.

This feature could also take into account the initial tokens for the bucket (though it won't be too difficult to do this ourselves).

For example:

• If we setup a bucket with 100 tokens that has a interval refill of 100 tokens every hour, specifying that the refill happens at start of an hour.
• bucket is created 20 minutes past the hour
• bucket gets initially created with 66 tokens (pro-rate of number of tokens for bucket with the time left to interval boundary) and refilled in 40 minutes (to align it to the hour boundary)
• after this first refill, it should there after be refilled with 100 tokens every 60 minutes.

I did notice that in original discussion of fixed interval buckets (https://github.com/vladimir-bukhtoyarov/bucket4j/issues/39), there was mention of "Instant timeOfFirstRefill" parameter that could have met this feature, but this wasn't implemented.

Hi,

This is in reference to old issue https://github.com/vladimir-bukhtoyarov/bucket4j/issues/45 where i would like to create dynamic capacity per hour.

Earlier version has concept of BandwidthAdjuster which kind of I am looking for. Not sure if it actually adjust bucket during run time when hour changes as feature has been decommissioned so can't test.

Can you suggest any alternative way to achieve below using new 4.* version of Bucket4J?

BandwidthAdjuster adjuster = new BandwidthAdjuster() { @Override public long getCapacity(long currentTime) { Calendar calendar = Calendar.getInstance(); calendar.setTimeInMillis(currentTime); int hour = calendar.get(Calendar.HOUR_OF_DAY); if (hour >= 7 && hour <= 23) { return 10;
} else { return 2; } } }; Buckets.withMillisTimePrecision() .withLimitedBandwidth(adjuster, TimeUnit.MINUTES, 1, 10);

I took below error stack.

java.lang.IllegalArgumentException: 0 is wrong value for period tokens, because tokens should be positive

at io.github.bucket4j.BucketExceptions.nonPositivePeriodTokens(BucketExceptions.java:106)
at io.github.bucket4j.Refill.<init>(Refill.java:46)
at io.github.bucket4j.Refill.greedy(Refill.java:95)

I read code related this issue. And find when capacity is set to 0, this library make exception.

public static Bandwidth classic(long capacity, Refill refill) {
        if (capacity <= 0) {
            throw BucketExceptions.nonPositiveCapacity(capacity);
        }
        if (refill == null) {
            throw BucketExceptions.nullBandwidthRefill();
        }
        return new Bandwidth(capacity, refill.periodNanos, refill.tokens, capacity, refill.refillIntervally, refill.timeOfFirstRefillMillis, refill.useAdaptiveInitialTokens);
    }

private Refill(long tokens, Duration period, boolean refillIntervally, long timeOfFirstRefillMillis, boolean useAdaptiveInitialTokens) {
        if (period == null) {
            throw BucketExceptions.nullRefillPeriod();
        }
        if (tokens <= 0) {
            throw BucketExceptions.nonPositivePeriodTokens(tokens);
        }
        this.periodNanos = period.toNanos();
        if (periodNanos <= 0) {
            throw BucketExceptions.nonPositivePeriod(periodNanos);
        }
...
}

Now I can set dynamically bucket size set. I sometimes want to stop to generate token.

How can I do this situation? Do you have any ideas?

I use spring boot, bucket4j+redis to build my app. and i deploy it in k8s cluster with 2 replicas. Here is maven

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.17.0</version>
        </dependency>

        <!-- Bucket4J starter = Bucket4J + JCache -->
        <dependency>
            <groupId>com.giffing.bucket4j.spring.boot.starter</groupId>
            <artifactId>bucket4j-spring-boot-starter</artifactId>
            <version>0.5.2</version>
            <exclusions>
                <exclusion>
                    <groupId>org.ehcache</groupId>
                    <artifactId>ehcache</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

Here is config for redis and proxyManager

@Configuration
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private String port;

    @Value("${spring.redis.password}")
    private String password;


    @Bean
    public Config config() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port);
        config.useSingleServer().setPassword(password);
        config.useSingleServer().setConnectionPoolSize(2);
        config.useSingleServer().setConnectionMinimumIdleSize(2);
        return config;
    }

    @Bean("tokenCache")
    public CacheManager cacheManager(Config config) {
        CacheManager manager = Caching.getCachingProvider().getCacheManager();
        manager.createCache(RedisKeyConstant.TOKEN_CONFIG_CACHE, RedissonConfiguration.fromConfig(config));
        return manager;
    }

    @Bean
    ProxyManager<String> proxyManager(CacheManager cacheManager) {
        return new JCacheProxyManager<>(cacheManager.getCache(RedisKeyConstant.TOKEN_CONFIG_CACHE));
    }
}

Here is my rate limiter

@Service
public class RateLimiter implements RateLimiter {
    @Autowired
    private ProxyManager<String> proxyManager;

    private Bucket bucket = null;

    public Bucket getBucket() {
        Supplier<BucketConfiguration> configSupplier = this.getConfigSupplierForUser();
        this.bucket = proxyManager.builder().build(ApiConstant.BUCKET, configSupplier);
        return this.bucket;
    }

    private Supplier<BucketConfiguration> getConfigSupplierForUser() {
        Refill refill = Refill.greedy(1, Duration.ofSeconds(1));
        Bandwidth limit = Bandwidth.classic(4, refill).withInitialTokens(4);
        return () -> (BucketConfiguration.builder()
                .addLimit(limit).build());
    }
}

Here is where i use rate limiter, I use it to limit the consumption speed for rabbitMq to limit Limit the rate of calling third-party APIs.

@Component
public class ConsumerMethod {
    private static final Logger logger = LoggerFactory.getLogger(ConsumerMethod.class);

    @Autowired
    private RateLimiter rateLimiter;

    @Bean
    Consumer<Message<String>> Consumer() {
        logger.info("init Consumer");
        return message -> onMessage(message);
    }

    public void onMessage(Message<String> message) {
        Channel channel = message.getHeaders().get(AmqpHeaders.CHANNEL, Channel.class);
        Long l = message.getHeaders().get(AmqpHeaders.DELIVERY_TAG, Long.class);
        DTO dto = JSON.parseObject(message.getPayload(), DTO.class);

        Bucket bucket = rateLimiter.getBucket();
        long availableTokens = bucket.getAvailableTokens();
        logger.info("-----------Before Available Tokens are " + availableTokens);
        try {
            if (bucket.asBlocking().tryConsume(1, Duration.ofSeconds(1))) {
                long availableTokens1 = bucket.getAvailableTokens();
                logger.info("-----------Token consumed successfully, after Available Tokens are " + availableTokens1);
                RabbitMqUtils.manualAck(channel, l);
                // Call third-party api
            } else {
                logger.error("-----------Token consumed failed.");
                RabbitMqUtils.manualAck(channel, l);
                // Do some failure methods.
            }
        } catch (InterruptedException e) {
            RabbitMqUtils.manualAck(channel, l);
            e.printStackTrace();
        }
    }

where is the log after processing the msg from rabbitMQ. And the starting number of each line is indicates which replica it belongs to.

1 2023-01-05 11:12:09.391 [n_group-1:28433]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are 4
2 2023-01-05 11:12:09.472 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are 4
1 2023-01-05 11:12:09.499 [n_group-1:28433]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Token consumed successfully, after Available Tokens are 3
1 2023-01-05 11:12:09.579 [n_group-1:28433]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are 2
2 2023-01-05 11:12:09.608 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Token consumed successfully, after Available Tokens are 2
2 2023-01-05 11:12:09.695 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are 1
1 2023-01-05 11:12:09.754 [n_group-1:28433]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Token consumed successfully, after Available Tokens are 1
1 2023-01-05 11:12:09.811 [n_group-1:28433]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are 0
2 2023-01-05 11:12:09.831 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Token consumed successfully, after Available Tokens are 0
2 2023-01-05 11:12:09.896 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are -1
2 2023-01-05 11:12:09.928 [n_group-1:28480] ERROR c.a.c.s.stream.ConsumerMethod       - -----------Token consumed failed.
2 2023-01-05 11:12:10.054 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are -1
2 2023-01-05 11:12:10.092 [n_group-1:28480] ERROR c.a.c.s.stream.ConsumerMethod       - -----------Token consumed failed.
2 2023-01-05 11:12:10.155 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are -1
2 2023-01-05 11:12:10.194 [n_group-1:28480] ERROR c.a.c.s.stream.ConsumerMethod       - -----------Token consumed failed.
2 2023-01-05 11:12:10.254 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are -1
2 2023-01-05 11:12:10.290 [n_group-1:28480] ERROR c.a.c.s.stream.ConsumerMethod       - -----------Token consumed failed.
2 2023-01-05 11:12:10.351 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are -1
2 2023-01-05 11:12:10.379 [n_group-1:28480] ERROR c.a.c.s.stream.ConsumerMethod       - -----------Token consumed failed.
2 2023-01-05 11:12:10.442 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are 0
1 2023-01-05 11:12:10.493 [n_group-1:28433]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Token consumed successfully, after Available Tokens are 0
1 2023-01-05 11:12:10.552 [n_group-1:28433]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are -1
1 2023-01-05 11:12:10.618 [n_group-1:28433] ERROR c.a.c.s.stream.ConsumerMethod       - -----------Token consumed failed.
1 2023-01-05 11:12:10.708 [n_group-1:28433]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are -1
1 2023-01-05 11:12:10.740 [n_group-1:28433] ERROR c.a.c.s.stream.ConsumerMethod       - -----------Token consumed failed.
1 2023-01-05 11:12:10.824 [n_group-1:28433]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Before Available Tokens are -1
1 2023-01-05 11:12:10.851 [n_group-1:28433] ERROR c.a.c.s.stream.ConsumerMethod       - -----------Token consumed failed.
2 2023-01-05 11:12:11.497 [n_group-1:28480]  INFO c.a.c.s.stream.ConsumerMethod       - -----------Token consumed successfully, after Available Tokens are 0

I wonder why the number of token in bucket can be -1, and is it the correct way to use bucket4j in multiple replicas case? How can i to optimize my app to limit the calling third-party api rate from multiple replicas?

Hi Team,

Iam trying bucket4j with redis in distributed environment. Iam using LettuceBasedProxyManager to connect to redis to get/store buckets in redis. My application is expecting redis to be up and running while starting application, also when redis goes down when application is running, my application going down. In my case i want to use redis as optional. If redis is down, my application should work fine with out rate limit. Can you please confirm is there any way to do this ?

Hi,

By any chance, is there any plan to support , e.g: Lettuce Redis cluster client? Looking at the current API LettuceBasedProxyManager only take a non clustered Redis client.

Thank you!

Hi, bucket4j looks great, however, it can't be used in Kotlin JS and Kotlin Native.

Have you considered implementing the core in Kotlin, so the library could be used with multiplatform projects as well?

See https://github.com/Kotlin/kotlinx.coroutines/issues/460

I noticed that the redis implementation has an option to add TTL and dynamo one does not. Was this ever considered? Could try raising a PR if there's nothing blocking the implementation.

Following functionality that were implemented in the scope of 7.0 still not documented yet:

• Redis support including previously implemented Redisson backend as well as new backends implemented in the scope of #273 #274 #275
• DynamoDB support.
• Caffeine support.
• Optimizations like batching, delaying, predicting.