need to fix one test case shouldGraduallyIncreaseLimitWhenHealthy failing for AdaptiveRateLimiter.java

Author: skamble2

pom.xml

@@ -246,6 +246,8 @@
     <module>visitor</module>
       <module>backpressure</module>
       <module>actor-model</module>
+      <module>rate-limiting-pattern</module>
+      <module>rate-limiting-pattern</module>
 
   </modules>
   <repositories>

rate-limiting-pattern/pom.xml

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.iluwatar</groupId>
+        <artifactId>java-design-patterns</artifactId>
+        <version>1.26.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>rate-limiter</artifactId>
+
+    <properties>
+        <maven.compiler.source>22</maven.compiler.source>
+        <maven.compiler.target>22</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <junit.jupiter.version>5.11.1</junit.jupiter.version>
+        <junit.platform.version>1.11.1</junit.platform.version>
+    </properties>
+
+    <dependencies>
+        <!-- JUnit 5 API and Engine -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>${junit.jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.24.2</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.1.2</version>
+                <configuration>
+                    <useModulePath>false</useModulePath> <!-- for Java 17+ compatibility -->
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

rate-limiting-pattern/src/main/java/com/iluwatar/rate/limiting/pattern/AdaptiveRateLimiter.java

@@ -0,0 +1,46 @@
+package com.iluwatar.rate.limiting.pattern;
+
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Adaptive rate limiter that adjusts limits based on system health.
+ */
+public class AdaptiveRateLimiter implements RateLimiter {
+  private final int initialLimit;
+  private final int maxLimit;
+  private final AtomicInteger currentLimit;
+  private final ConcurrentHashMap<String, RateLimiter> limiters = new ConcurrentHashMap<>();
+  private final ScheduledExecutorService healthChecker = Executors.newScheduledThreadPool(1);
+
+  public AdaptiveRateLimiter(int initialLimit, int maxLimit) {
+    this.initialLimit = initialLimit;
+    this.maxLimit = maxLimit;
+    this.currentLimit = new AtomicInteger(initialLimit);
+    healthChecker.scheduleAtFixedRate(this::adjustLimits, 10, 10, TimeUnit.SECONDS);
+  }
+
+  @Override
+  public void check(String serviceName, String operationName) throws RateLimitException {
+    String key = serviceName + ":" + operationName;
+    int current = currentLimit.get();
+
+    RateLimiter limiter = limiters.computeIfAbsent(key,
+        k -> new TokenBucketRateLimiter(current, current));
+
+    try {
+      limiter.check(serviceName, operationName);
+      System.out.printf("[Adaptive] Allowed %s.%s - CurrentLimit: %d%n", serviceName, operationName, current);
+    } catch (RateLimitException e) {
+      currentLimit.updateAndGet(curr -> Math.max(initialLimit, curr / 2));
+      System.out.printf("[Adaptive] Throttled %s.%s - Decreasing limit to %d%n",
+          serviceName, operationName, currentLimit.get());
+      throw e;
+    }
+  }
+
+  private void adjustLimits() {
+    int updated = currentLimit.updateAndGet(curr -> Math.min(maxLimit, curr + (initialLimit / 2)));
+    System.out.printf("[Adaptive] Health check passed - Increasing limit to %d%n", updated);
+  }
+}

rate-limiting-pattern/src/main/java/com/iluwatar/rate/limiting/pattern/App.java

@@ -0,0 +1,164 @@
+package com.iluwatar.rate.limiting.pattern;
+
+import java.util.Random;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * The <em>Rate Limiter</em> pattern is a key defensive strategy used to prevent system overload
+ * and ensure fair usage of shared services. This demo showcases how different rate limiting techniques
+ * can regulate traffic in distributed systems.
+ *
+ * <p>Specifically, this simulation implements three rate limiter strategies:
+ *
+ * <ul>
+ *   <li><b>Token Bucket</b> – Allows short bursts followed by steady request rates.</li>
+ *   <li><b>Fixed Window</b> – Enforces a strict limit per discrete time window (e.g., 3 requests/sec).</li>
+ *   <li><b>Adaptive</b> – Dynamically scales limits based on system health, simulating elastic backoff.</li>
+ * </ul>
+ *
+ * <p>Each simulated service (e.g., S3, DynamoDB, Lambda) is governed by one of these limiters. Multiple
+ * concurrent client threads issue randomized requests to these services over a fixed duration. Each
+ * request is either:
+ *
+ * <ul>
+ *   <li><b>ALLOWED</b> – Permitted under the current rate limit</li>
+ *   <li><b>THROTTLED</b> – Rejected due to quota exhaustion</li>
+ *   <li><b>FAILED</b> – Dropped due to transient service failure</li>
+ * </ul>
+ *
+ * <p>Statistics are printed every few seconds, and the simulation exits gracefully after a fixed runtime,
+ * offering a clear view into how each limiter behaves under pressure.
+ *
+ * <p><b>Relation to AWS API Gateway:</b><br>
+ * This implementation mirrors the throttling behavior described in the
+ * <a href="https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html">
+ * AWS API Gateway Request Throttling documentation</a>, where limits are applied per second and over
+ * longer durations (burst and rate limits). The <code>TokenBucketRateLimiter</code> mimics burst capacity,
+ * the <code>FixedWindowRateLimiter</code> models steady rate enforcement, and the <code>AdaptiveRateLimiter</code>
+ * reflects elasticity in real-world systems like AWS Lambda under variable load.
+ *
+ * */
+public final class App {
+  private static final int RUN_DURATION_SECONDS = 10;
+  private static final int SHUTDOWN_TIMEOUT_SECONDS = 5;
+
+  private static final AtomicInteger successfulRequests = new AtomicInteger();
+  private static final AtomicInteger throttledRequests = new AtomicInteger();
+  private static final AtomicInteger failedRequests = new AtomicInteger();
+  private static final AtomicBoolean running = new AtomicBoolean(true);
+
+  public static void main(String[] args) {
+    System.out.println("\nStarting Rate Limiter Demo");
+    System.out.println("====================================");
+
+    ExecutorService executor = Executors.newFixedThreadPool(3);
+    ScheduledExecutorService statsPrinter = Executors.newSingleThreadScheduledExecutor();
+
+    try {
+      // Explicit limiter setup for demonstration clarity
+      TokenBucketRateLimiter tb = new TokenBucketRateLimiter(2, 1); // capacity 2, refill 1/sec
+      FixedWindowRateLimiter fw = new FixedWindowRateLimiter(3, 1); // max 3 req/sec
+      AdaptiveRateLimiter ar = new AdaptiveRateLimiter(2, 6);       // adaptive from 2 to 6 req/sec
+
+      // Print statistics every 2 seconds
+      statsPrinter.scheduleAtFixedRate(App::printStats, 2, 2, TimeUnit.SECONDS);
+
+      // Launch 3 simulated clients
+      for (int i = 1; i <= 3; i++) {
+        executor.submit(createClientTask(i, tb, fw, ar));
+      }
+
+      // Run simulation for N seconds
+      Thread.sleep(RUN_DURATION_SECONDS * 1000L);
+      System.out.println("\nShutting down the demo...");
+
+      running.set(false);
+      executor.shutdown();
+      statsPrinter.shutdown();
+
+      if (!executor.awaitTermination(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
+        executor.shutdownNow();
+      }
+      if (!statsPrinter.awaitTermination(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
+        statsPrinter.shutdownNow();
+      }
+
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+    } finally {
+      printFinalStats();
+      System.out.println("Demo completed.");
+    }
+  }
+
+  private static Runnable createClientTask(int clientId,
+                                           RateLimiter s3Limiter,
+                                           RateLimiter dynamoDbLimiter,
+                                           RateLimiter lambdaLimiter) {
+    return () -> {
+      String[] services = {"s3", "dynamodb", "lambda"};
+      String[] operations = {
+          "GetObject", "PutObject", "Query", "Scan", "PutItem", "Invoke", "ListFunctions"
+      };
+      Random random = new Random();
+
+      while (running.get() && !Thread.currentThread().isInterrupted()) {
+        try {
+          String service = services[random.nextInt(services.length)];
+          String operation = operations[random.nextInt(operations.length)];
+
+          switch (service) {
+            case "s3" -> makeRequest(clientId, s3Limiter, service, operation);
+            case "dynamodb" -> makeRequest(clientId, dynamoDbLimiter, service, operation);
+            case "lambda" -> makeRequest(clientId, lambdaLimiter, service, operation);
+          }
+
+          Thread.sleep(30 + random.nextInt(50));
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+        }
+      }
+    };
+  }
+
+  private static void makeRequest(int clientId, RateLimiter limiter,
+                                  String service, String operation) {
+    try {
+      limiter.check(service, operation);
+      successfulRequests.incrementAndGet();
+      System.out.printf("Client %d: %s.%s - ALLOWED%n", clientId, service, operation);
+    } catch (ThrottlingException e) {
+      throttledRequests.incrementAndGet();
+      System.out.printf("Client %d: %s.%s - THROTTLED (Retry in %dms)%n",
+          clientId, service, operation, e.getRetryAfterMillis());
+    } catch (ServiceUnavailableException e) {
+      failedRequests.incrementAndGet();
+      System.out.printf("Client %d: %s.%s - SERVICE UNAVAILABLE%n",
+          clientId, service, operation);
+    } catch (Exception e) {
+      failedRequests.incrementAndGet();
+      System.out.printf("Client %d: %s.%s - ERROR: %s%n",
+          clientId, service, operation, e.getMessage());
+    }
+  }
+
+  private static void printStats() {
+    if (!running.get()) return;
+    System.out.println("\n=== Current Statistics ===");
+    System.out.printf("Successful Requests: %d%n", successfulRequests.get());
+    System.out.printf("Throttled Requests : %d%n", throttledRequests.get());
+    System.out.printf("Failed Requests    : %d%n", failedRequests.get());
+    System.out.println("==========================\n");
+  }
+
+  private static void printFinalStats() {
+    System.out.println("\nFinal Statistics");
+    System.out.println("==========================");
+    System.out.printf("Successful Requests: %d%n", successfulRequests.get());
+    System.out.printf("Throttled Requests : %d%n", throttledRequests.get());
+    System.out.printf("Failed Requests    : %d%n", failedRequests.get());
+    System.out.println("==========================");
+  }
+}

rate-limiting-pattern/src/main/java/com/iluwatar/rate/limiting/pattern/FindCustomerRequest.java

@@ -0,0 +1,38 @@
+package com.iluwatar.rate.limiting.pattern;
+
+/**
+ * Example operation implementation for finding customers.
+ */
+public class FindCustomerRequest implements RateLimitOperation<String> {
+  private final String customerId;
+  private final RateLimiter rateLimiter;
+
+  public FindCustomerRequest(String customerId, RateLimiter rateLimiter) {
+    this.customerId = customerId;
+    this.rateLimiter = rateLimiter;
+  }
+
+  @Override
+  public String getServiceName() {
+    return "CustomerService";
+  }
+
+  @Override
+  public String getOperationName() {
+    return "FindCustomer";
+  }
+
+  @Override
+  public String execute() throws RateLimitException {
+    rateLimiter.check(getServiceName(), getOperationName());
+
+    // Simulate actual operation
+    try {
+      Thread.sleep(50); // Simulate processing time
+      return "Customer-" + customerId;
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      throw new ServiceUnavailableException(getServiceName(), 1000);
+    }
+  }
+}

rate-limiting-pattern/src/main/java/com/iluwatar/rate/limiting/pattern/FixedWindowRateLimiter.java

@@ -0,0 +1,46 @@
+package com.iluwatar.rate.limiting.pattern;
+
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Fixed window rate limiter implementation.
+ */
+public class FixedWindowRateLimiter implements RateLimiter {
+  private final int limit;
+  private final long windowMillis;
+  private final ConcurrentHashMap<String, WindowCounter> counters = new ConcurrentHashMap<>();
+
+  public FixedWindowRateLimiter(int limit, long windowSeconds) {
+    this.limit = limit;
+    this.windowMillis = TimeUnit.SECONDS.toMillis(windowSeconds);
+  }
+
+  @Override
+  public synchronized void check(String serviceName, String operationName) throws RateLimitException {
+    String key = serviceName + ":" + operationName;
+    WindowCounter counter = counters.computeIfAbsent(key, k -> new WindowCounter());
+
+    if (!counter.tryIncrement()) {
+      System.out.printf("[FixedWindow] Throttled %s.%s - Limit %d reached in window%n",
+          serviceName, operationName, limit);
+      throw new RateLimitException("Rate limit exceeded for " + key, windowMillis);
+    } else {
+      System.out.printf("[FixedWindow] Allowed %s.%s - Count within window%n", serviceName, operationName);
+    }
+  }
+
+  private class WindowCounter {
+    private AtomicInteger count = new AtomicInteger(0);
+    private volatile long windowStart = System.currentTimeMillis();
+
+    synchronized boolean tryIncrement() {
+      long now = System.currentTimeMillis();
+      if (now - windowStart > windowMillis) {
+        count.set(0);
+        windowStart = now;
+      }
+      return count.incrementAndGet() <= limit;
+    }
+  }
+}

rate-limiting-pattern/src/main/java/com/iluwatar/rate/limiting/pattern/RateLimitException.java

@@ -0,0 +1,17 @@
+package com.iluwatar.rate.limiting.pattern;
+
+/**
+ * Base exception for rate limiting errors.
+ */
+public class RateLimitException extends Exception {
+  private final long retryAfterMillis;
+
+  public RateLimitException(String message, long retryAfterMillis) {
+    super(message);
+    this.retryAfterMillis = retryAfterMillis;
+  }
+
+  public long getRetryAfterMillis() {
+    return retryAfterMillis;
+  }
+}

rate-limiting-pattern/src/main/java/com/iluwatar/rate/limiting/pattern/RateLimitOperation.java

@@ -0,0 +1,10 @@
+package com.iluwatar.rate.limiting.pattern;
+
+/**
+ * Interface representing an operation that needs rate limiting.
+ */
+public interface RateLimitOperation<T> {
+  String getServiceName();
+  String getOperationName();
+  T execute() throws RateLimitException;
+}