Add ResilienceCircuitBreakerFactory class

Author: pavan-traceable

grpc-circuitbreaker-utils/src/main/java/org/hypertrace/circuitbreaker/grpcutils/CircuitBreakerConfigParser.java

@@ -10,7 +10,6 @@
 @Slf4j
 public class CircuitBreakerConfigParser {
 
-  public static final String DEFAULT_CONFIG_KEY = "default";
   private static final Set<String> nonThresholdKeys =
       Set.of("enabled", "defaultCircuitBreakerKey", "defaultThresholds");
 
@@ -32,7 +31,6 @@ public class CircuitBreakerConfigParser {
       "permittedNumberOfCallsInHalfOpenState";
   private static final String SLIDING_WINDOW_TYPE = "slidingWindowType";
   public static final String ENABLED = "enabled";
-  public static final String DEFAULT_CIRCUIT_BREAKER_KEY = "defaultCircuitBreakerKey";
   public static final String DEFAULT_THRESHOLDS = "defaultThresholds";
 
   public static <T> CircuitBreakerConfiguration.CircuitBreakerConfigurationBuilder<T> parseConfig(
@@ -43,10 +41,6 @@ public static <T> CircuitBreakerConfiguration.CircuitBreakerConfigurationBuilder
       builder.enabled(config.getBoolean(ENABLED));
     }
 
-    if (config.hasPath(DEFAULT_CIRCUIT_BREAKER_KEY)) {
-      builder.defaultCircuitBreakerKey(config.getString(DEFAULT_CIRCUIT_BREAKER_KEY));
-    }
-
     if (config.hasPath(DEFAULT_THRESHOLDS)) {
       builder.defaultThresholds(
           buildCircuitBreakerThresholds(config.getConfig(DEFAULT_THRESHOLDS)));
@@ -62,7 +56,7 @@ public static <T> CircuitBreakerConfiguration.CircuitBreakerConfigurationBuilder
                     key -> key, // Circuit breaker key
                     key -> buildCircuitBreakerThresholds(config.getConfig(key))));
     builder.circuitBreakerThresholdsMap(circuitBreakerThresholdsMap);
-    log.info("Loaded circuit breaker configs: {}", builder);
+    log.debug("Loaded circuit breaker configs: {}", builder);
     return builder;
   }
 

grpc-circuitbreaker-utils/src/main/java/org/hypertrace/circuitbreaker/grpcutils/CircuitBreakerConfiguration.java

@@ -1,7 +1,9 @@
 package org.hypertrace.circuitbreaker.grpcutils;
 
+import io.grpc.Status;
 import java.util.Map;
 import java.util.function.BiFunction;
+import java.util.function.Function;
 import lombok.Builder;
 import lombok.Value;
 import org.hypertrace.core.grpcutils.context.RequestContext;
@@ -13,9 +15,14 @@ public class CircuitBreakerConfiguration<T> {
   BiFunction<RequestContext, T, String> keyFunction;
   @Builder.Default boolean enabled = false;
   // Default value be "global" if not override.
-  @Builder.Default String defaultCircuitBreakerKey = "global";
+  String defaultCircuitBreakerKey = "global";
   // Standard/default thresholds
   CircuitBreakerThresholds defaultThresholds;
   // Custom overrides for specific cases (less common)
   @Builder.Default Map<String, CircuitBreakerThresholds> circuitBreakerThresholdsMap = Map.of();
+
+  // New exception builder logic
+  @Builder.Default
+  Function<String, RuntimeException> exceptionBuilder =
+      reason -> Status.RESOURCE_EXHAUSTED.withDescription(reason).asRuntimeException();
 }

grpc-circuitbreaker-utils/src/main/java/org/hypertrace/circuitbreaker/grpcutils/resilience/ResilienceCircuitBreakerConfigConverter.java

@@ -6,7 +6,7 @@
 import org.hypertrace.circuitbreaker.grpcutils.CircuitBreakerThresholds;
 
 /** Utility class to parse CircuitBreakerConfiguration to Resilience4j CircuitBreakerConfig */
-public class ResilienceCircuitBreakerConfigConverter {
+class ResilienceCircuitBreakerConfigConverter {
 
   public static Map<String, CircuitBreakerConfig> getCircuitBreakerConfigs(
       Map<String, CircuitBreakerThresholds> configurationMap) {

grpc-circuitbreaker-utils/src/main/java/org/hypertrace/circuitbreaker/grpcutils/resilience/ResilienceCircuitBreakerFactory.java

@@ -0,0 +1,25 @@
+package org.hypertrace.circuitbreaker.grpcutils.resilience;
+
+import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
+import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
+import java.time.Clock;
+import java.util.Map;
+import org.hypertrace.circuitbreaker.grpcutils.CircuitBreakerConfiguration;
+
+public class ResilienceCircuitBreakerFactory {
+  public static ResilienceCircuitBreakerInterceptor getResilienceCircuitBreakerInterceptor(
+      CircuitBreakerConfiguration<?> circuitBreakerConfiguration, Clock clock) {
+    Map<String, CircuitBreakerConfig> resilienceCircuitBreakerConfigMap =
+        ResilienceCircuitBreakerConfigConverter.getCircuitBreakerConfigs(
+            circuitBreakerConfiguration.getCircuitBreakerThresholdsMap());
+    CircuitBreakerRegistry resilicenceCircuitBreakerRegistry =
+        new ResilienceCircuitBreakerRegistryProvider(
+                circuitBreakerConfiguration.getDefaultThresholds())
+            .getCircuitBreakerRegistry();
+    ResilienceCircuitBreakerProvider resilienceCircuitBreakerProvider =
+        new ResilienceCircuitBreakerProvider(
+            resilicenceCircuitBreakerRegistry, resilienceCircuitBreakerConfigMap);
+    return new ResilienceCircuitBreakerInterceptor(
+        circuitBreakerConfiguration, clock, resilienceCircuitBreakerProvider);
+  }
+}

grpc-circuitbreaker-utils/src/main/java/org/hypertrace/circuitbreaker/grpcutils/resilience/ResilienceCircuitBreakerInterceptor.java

@@ -1,8 +1,6 @@
 package org.hypertrace.circuitbreaker.grpcutils.resilience;
 
 import io.github.resilience4j.circuitbreaker.CircuitBreaker;
-import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
-import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
 import io.grpc.CallOptions;
 import io.grpc.Channel;
 import io.grpc.ClientCall;
@@ -24,40 +22,17 @@
 @Slf4j
 public class ResilienceCircuitBreakerInterceptor extends CircuitBreakerInterceptor {
 
-  private final CircuitBreakerRegistry resilicenceCircuitBreakerRegistry;
-  private final Map<String, CircuitBreakerConfig> resilienceCircuitBreakerConfigMap;
   private final ResilienceCircuitBreakerProvider resilienceCircuitBreakerProvider;
   private final CircuitBreakerConfiguration<?> circuitBreakerConfiguration;
   private final Clock clock;
 
-  public ResilienceCircuitBreakerInterceptor(
-      CircuitBreakerConfiguration<?> circuitBreakerConfiguration, Clock clock) {
-    this.circuitBreakerConfiguration = circuitBreakerConfiguration;
-    this.clock = clock;
-    this.resilienceCircuitBreakerConfigMap =
-        ResilienceCircuitBreakerConfigConverter.getCircuitBreakerConfigs(
-            circuitBreakerConfiguration.getCircuitBreakerThresholdsMap());
-    this.resilicenceCircuitBreakerRegistry =
-        new ResilienceCircuitBreakerRegistryProvider(
-                circuitBreakerConfiguration.getDefaultThresholds())
-            .getCircuitBreakerRegistry();
-    this.resilienceCircuitBreakerProvider =
-        new ResilienceCircuitBreakerProvider(
-            resilicenceCircuitBreakerRegistry, resilienceCircuitBreakerConfigMap);
-  }
-
-  public ResilienceCircuitBreakerInterceptor(
+  ResilienceCircuitBreakerInterceptor(
       CircuitBreakerConfiguration<?> circuitBreakerConfiguration,
       Clock clock,
-      CircuitBreakerRegistry resilicenceCircuitBreakerRegistry,
       ResilienceCircuitBreakerProvider resilienceCircuitBreakerProvider) {
     this.circuitBreakerConfiguration = circuitBreakerConfiguration;
-    this.resilienceCircuitBreakerConfigMap =
-        ResilienceCircuitBreakerConfigConverter.getCircuitBreakerConfigs(
-            circuitBreakerConfiguration.getCircuitBreakerThresholdsMap());
-    this.resilicenceCircuitBreakerRegistry = resilicenceCircuitBreakerRegistry;
-    this.resilienceCircuitBreakerProvider = resilienceCircuitBreakerProvider;
     this.clock = clock;
+    this.resilienceCircuitBreakerProvider = resilienceCircuitBreakerProvider;
   }
 
   @Override
@@ -100,7 +75,7 @@ public void sendMessage(ReqT message) {
               circuitBreaker.getState() == CircuitBreaker.State.HALF_OPEN
                   ? "Circuit Breaker is HALF-OPEN and rejecting excess requests"
                   : "Circuit Breaker is OPEN and blocking requests";
-          throw Status.RESOURCE_EXHAUSTED.withDescription(rejectionReason).asRuntimeException();
+          throw config.getExceptionBuilder().apply(rejectionReason);
         }
         super.sendMessage(message);
       }

grpc-circuitbreaker-utils/src/main/java/org/hypertrace/circuitbreaker/grpcutils/resilience/ResilienceCircuitBreakerProvider.java

@@ -10,7 +10,7 @@
 
 /** Utility class to provide Resilience4j CircuitBreaker */
 @Slf4j
-public class ResilienceCircuitBreakerProvider {
+class ResilienceCircuitBreakerProvider {
 
   private final CircuitBreakerRegistry circuitBreakerRegistry;
   private final Map<String, CircuitBreakerConfig> circuitBreakerConfigMap;
@@ -27,11 +27,7 @@ public CircuitBreaker getCircuitBreaker(String circuitBreakerKey) {
     return circuitBreakerCache.computeIfAbsent(
         circuitBreakerKey,
         key -> {
-          CircuitBreaker circuitBreaker =
-              Optional.ofNullable(circuitBreakerConfigMap.get(circuitBreakerKey))
-                  .map(config -> circuitBreakerRegistry.circuitBreaker(circuitBreakerKey, config))
-                  .orElseGet(() -> circuitBreakerRegistry.circuitBreaker(circuitBreakerKey));
-
+          CircuitBreaker circuitBreaker = getCircuitBreakerFromConfigMap(circuitBreakerKey);
           circuitBreaker
               .getEventPublisher()
               .onStateTransition(
@@ -54,4 +50,10 @@ public CircuitBreaker getCircuitBreaker(String circuitBreakerKey) {
           return circuitBreaker;
         });
   }
+
+  private CircuitBreaker getCircuitBreakerFromConfigMap(String circuitBreakerKey) {
+    return Optional.ofNullable(circuitBreakerConfigMap.get(circuitBreakerKey))
+        .map(config -> circuitBreakerRegistry.circuitBreaker(circuitBreakerKey, config))
+        .orElseGet(() -> circuitBreakerRegistry.circuitBreaker(circuitBreakerKey));
+  }
 }

grpc-circuitbreaker-utils/src/main/java/org/hypertrace/circuitbreaker/grpcutils/resilience/ResilienceCircuitBreakerRegistryProvider.java

@@ -7,7 +7,7 @@
 
 /** Utility class to provide Resilience4j CircuitBreakerRegistry */
 @Slf4j
-public class ResilienceCircuitBreakerRegistryProvider {
+class ResilienceCircuitBreakerRegistryProvider {
   private final CircuitBreakerThresholds circuitBreakerThresholds;
 
   public ResilienceCircuitBreakerRegistryProvider(
@@ -24,12 +24,12 @@ public CircuitBreakerRegistry getCircuitBreakerRegistry() {
         .onEntryAdded(
             entryAddedEvent -> {
               CircuitBreaker addedCircuitBreaker = entryAddedEvent.getAddedEntry();
-              log.info("CircuitBreaker {} added", addedCircuitBreaker.getName());
+              log.debug("CircuitBreaker {} added", addedCircuitBreaker.getName());
             })
         .onEntryRemoved(
             entryRemovedEvent -> {
               CircuitBreaker removedCircuitBreaker = entryRemovedEvent.getRemovedEntry();
-              log.info("CircuitBreaker {} removed", removedCircuitBreaker.getName());
+              log.debug("CircuitBreaker {} removed", removedCircuitBreaker.getName());
             });
     return circuitBreakerRegistry;
   }

grpc-circuitbreaker-utils/src/test/java/org/hypertrace/circuitbreaker/grpcutils/resilience/ResilienceCircuitBreakerInterceptorTest.java

@@ -11,9 +11,7 @@
 import java.time.Clock;
 import java.time.Instant;
 import java.time.ZoneOffset;
-import java.util.Map;
 import java.util.concurrent.TimeUnit;
-import org.hypertrace.circuitbreaker.grpcutils.CircuitBreakerConfigParser;
 import org.hypertrace.circuitbreaker.grpcutils.CircuitBreakerConfiguration;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -42,13 +40,8 @@ void setUp() {
 
     fixedClock = Clock.fixed(Instant.now(), ZoneOffset.UTC);
     when(mockChannel.newCall(any(), any())).thenReturn(mockClientCall);
-    //    when(mockCircuitBreakerRegistryProvider.getCircuitBreakerRegistry())
-    //        .thenReturn(mockCircuitBreakerRegistry);
     when(mockCircuitBreakerProvider.getCircuitBreaker(anyString())).thenReturn(mockCircuitBreaker);
     when(mockCircuitBreakerConfig.getDefaultCircuitBreakerKey()).thenReturn("global");
-    when(mockCircuitBreakerConfig.getCircuitBreakerThresholdsMap())
-        .thenReturn(
-            Map.of("global", CircuitBreakerConfigParser.buildCircuitBreakerDefaultThresholds()));
   }
 
   @Test
@@ -58,10 +51,7 @@ void testSendMessage_CallsSuperSendMessage_Success() {
 
     ResilienceCircuitBreakerInterceptor interceptor =
         new ResilienceCircuitBreakerInterceptor(
-            mockCircuitBreakerConfig,
-            fixedClock,
-            mockCircuitBreakerRegistry,
-            mockCircuitBreakerProvider);
+            mockCircuitBreakerConfig, fixedClock, mockCircuitBreakerProvider);
 
     ClientCall<Object, Object> interceptedCall =
         interceptor.createInterceptedCall(
@@ -77,12 +67,14 @@ void testSendMessage_CallsSuperSendMessage_Success() {
   void testSendMessage_CircuitBreakerRejectsRequest() {
     when(mockCircuitBreaker.tryAcquirePermission()).thenReturn(false);
     when(mockCircuitBreaker.getState()).thenReturn(CircuitBreaker.State.OPEN);
+    when(mockCircuitBreakerConfig.getExceptionBuilder())
+        .thenReturn(
+            reason ->
+                new StatusRuntimeException(
+                    Status.RESOURCE_EXHAUSTED.withDescription(reason), mock(Metadata.class)));
     ResilienceCircuitBreakerInterceptor interceptor =
         new ResilienceCircuitBreakerInterceptor(
-            mockCircuitBreakerConfig,
-            fixedClock,
-            mockCircuitBreakerRegistry,
-            mockCircuitBreakerProvider);
+            mockCircuitBreakerConfig, fixedClock, mockCircuitBreakerProvider);
 
     ClientCall<Object, Object> interceptedCall =
         interceptor.createInterceptedCall(
@@ -102,12 +94,14 @@ void testSendMessage_CircuitBreakerRejectsRequest() {
   void testSendMessage_CircuitBreakerInHalfOpenState() {
     when(mockCircuitBreaker.tryAcquirePermission()).thenReturn(false);
     when(mockCircuitBreaker.getState()).thenReturn(CircuitBreaker.State.HALF_OPEN);
+    when(mockCircuitBreakerConfig.getExceptionBuilder())
+        .thenReturn(
+            reason ->
+                new StatusRuntimeException(
+                    Status.RESOURCE_EXHAUSTED.withDescription(reason), mock(Metadata.class)));
     ResilienceCircuitBreakerInterceptor interceptor =
         new ResilienceCircuitBreakerInterceptor(
-            mockCircuitBreakerConfig,
-            fixedClock,
-            mockCircuitBreakerRegistry,
-            mockCircuitBreakerProvider);
+            mockCircuitBreakerConfig, fixedClock, mockCircuitBreakerProvider);
 
     ClientCall<Object, Object> interceptedCall =
         interceptor.createInterceptedCall(
@@ -128,10 +122,7 @@ void testWrapListenerWithCircuitBreaker_Success() {
     when(mockCircuitBreaker.tryAcquirePermission()).thenReturn(true);
     ResilienceCircuitBreakerInterceptor interceptor =
         new ResilienceCircuitBreakerInterceptor(
-            mockCircuitBreakerConfig,
-            fixedClock,
-            mockCircuitBreakerRegistry,
-            mockCircuitBreakerProvider);
+            mockCircuitBreakerConfig, fixedClock, mockCircuitBreakerProvider);
 
     ClientCall<Object, Object> interceptedCall =
         interceptor.createInterceptedCall(
@@ -155,10 +146,7 @@ void testWrapListenerWithCircuitBreaker_Failure() {
     when(mockCircuitBreaker.tryAcquirePermission()).thenReturn(true);
     ResilienceCircuitBreakerInterceptor interceptor =
         new ResilienceCircuitBreakerInterceptor(
-            mockCircuitBreakerConfig,
-            fixedClock,
-            mockCircuitBreakerRegistry,
-            mockCircuitBreakerProvider);
+            mockCircuitBreakerConfig, fixedClock, mockCircuitBreakerProvider);
 
     ClientCall<Object, Object> interceptedCall =
         interceptor.createInterceptedCall(