Spring Cloud Circuitbreaker

https://github.com/spring-cloud/spring-cloud-circuitbreaker
Admin
Spring Cloud Circuitbreaker provides implementations for circuit breaker patterns in Spring Cloud...
Tokens:93,440
Snippets:638
Trust Score:9.5
License:Apache-2.0
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### FrameworkRetryConfig and FrameworkRetryConfigBuilder

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Documentation for the FrameworkRetryConfig class and its builder, including methods, parameters, and usage example.

```APIDOC
## FrameworkRetryConfig

### Description
Immutable-by-convention value object populated by `FrameworkRetryConfigBuilder`. Setter methods are package-private (return `this`).

### Methods

#### `getId()`

```java
public @Nullable String getId()
```

- **Returns:** the circuit breaker identifier, or `null` if unset.

#### `getCircuitBreakerRetryPolicy()`

```java
public @Nullable CircuitBreakerRetryPolicy getCircuitBreakerRetryPolicy()
```

- **Returns:** the `CircuitBreakerRetryPolicy`, or `null` if unset. `null` triggers the `Assert.notNull` failure in `FrameworkRetryCircuitBreaker.run`.

#### `getRetryPolicy()`

```java
public @Nullable RetryPolicy getRetryPolicy()
```

- **Returns:** the underlying `RetryPolicy`, or `null` if unset.

## FrameworkRetryConfigBuilder

### Description
Builder for `FrameworkRetryConfig`. Defaults: `retryPolicy = RetryPolicy.withDefaults()` (3 retry attempts with a 1 second delay), `openTimeout = Duration.ofSeconds(20)`, `resetTimeout = Duration.ofSeconds(5)`.

### Constructor

```java
public FrameworkRetryConfigBuilder(String id)
```

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| id | `String` | yes | — | Circuit breaker identifier |

### Methods

#### `retryPolicy(RetryPolicy)`

```java
public FrameworkRetryConfigBuilder retryPolicy(RetryPolicy retryPolicy)
```

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| retryPolicy | `RetryPolicy` (org.springframework.core.retry) | yes | `RetryPolicy.withDefaults()` | Policy applied while the circuit is closed; e.g. `withMaxRetries(int)`, `withMaxDuration(Duration)`, `withBackoff(Duration, double)`, `forExceptions(Class<?>...)`, combinable with `and()`/`or()` |

- **Returns:** this builder.

#### `openTimeout(Duration)`

```java
public FrameworkRetryConfigBuilder openTimeout(Duration openTimeout)
```

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| openTimeout | `Duration` | yes | `Duration.ofSeconds(20)` | Time the circuit stays open before moving to half-open |

- **Returns:** this builder.

#### `resetTimeout(Duration)`

```java
public FrameworkRetryConfigBuilder resetTimeout(Duration resetTimeout)
```

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| resetTimeout | `Duration` | yes | `Duration.ofSeconds(5)` | If no failure occurs within this window, state resets to closed |

- **Returns:** this builder.

#### `build()`

```java
@Override
public FrameworkRetryConfig build()
```

- **Returns:** a `FrameworkRetryConfig` with `id` set, `retryPolicy` set, and `circuitBreakerRetryPolicy = new CircuitBreakerRetryPolicy(this.retryPolicy, this.openTimeout, this.resetTimeout)`.

### Example

```java
FrameworkRetryConfig config = new FrameworkRetryConfigBuilder("bookService")
    .retryPolicy(RetryPolicy.withMaxRetries(3)
        .and(RetryPolicy.withMaxDuration(Duration.ofSeconds(5)))
        .forExceptions(IOException.class, TimeoutException.class))
    .openTimeout(Duration.ofSeconds(20))
    .resetTimeout(Duration.ofSeconds(5))
    .build();
```
```

--------------------------------

### Factory instantiation and usage example

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-reactive-circuit-breaker.md

Shows how to instantiate the factory and configure default circuit breaker and time limiter settings, then create circuit breakers for specific backends.

```java
ReactiveResilience4JCircuitBreakerFactory factory = new ReactiveResilience4JCircuitBreakerFactory(
        circuitBreakerRegistry, timeLimiterRegistry, bulkheadProvider, properties);

// interface Example
factory.configureDefault(id -> new Resilience4JConfigBuilder(id)
        .circuitBreakerConfig(CircuitBreakerConfig.ofDefaults())
        .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofSeconds(4)).build())
        .build());

// group-based resolution
ReactiveCircuitBreaker cbA = factory.create("backendA", "groupA");
ReactiveCircuitBreaker cbB = factory.create("backendC", "groupC");
```

--------------------------------

### Create and run FrameworkRetryCircuitBreaker

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Example of creating a FrameworkRetryCircuitBreaker with a FrameworkRetryConfigBuilder and running an invocation with a fallback. The fallback returns a constant string when the invocation fails.

```java
FrameworkRetryConfig config = new FrameworkRetryConfigBuilder("bookService").build();
CircuitBreaker cb = new FrameworkRetryCircuitBreaker("bookService", config);

String title = cb.run(() -> restTemplate.getForObject("/books/1", String.class),
                      throwable -> "Fallback Book");
```

--------------------------------

### Configure default bulkhead with maxConcurrentCalls(4)

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Example from project docs showing how to configure a default bulkhead configuration using configureDefault. Sets maxConcurrentCalls to 4 and thread pool sizes to 1.

```java
@Bean
public Customizer<Resilience4jBulkheadProvider> defaultBulkheadCustomizer() {
    return provider -> provider.configureDefault(id -> new Resilience4jBulkheadConfigurationBuilder()
        .bulkheadConfig(BulkheadConfig.custom().maxConcurrentCalls(4).build())
        .threadPoolBulkheadConfig(ThreadPoolBulkheadConfig.custom().coreThreadPoolSize(1).maxThreadPoolSize(1).build())
        .build());
}
```

--------------------------------

### Resetting the policy

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Example of resetting the policy to CLOSED before a clean run.

```java
policy.reset(); // back to CLOSED before a clean run
```

--------------------------------

### Default customizer bean example

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-reactive-circuit-breaker.md

Example bean that configures a default circuit breaker with a 4-second timeout using the configureDefault method.

```java
@Bean
public Customizer<ReactiveResilience4JCircuitBreakerFactory> defaultCustomizer() {
    return factory -> factory.configureDefault(id -> new Resilience4JConfigBuilder(id)
        .circuitBreakerConfig(CircuitBreakerConfig.ofDefaults())
        .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofSeconds(4)).build())
        .build());
}
```

--------------------------------

### SpringRetryCircuitBreaker usage example

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/spring-retry.md

Example usage: builds a SpringRetryConfig with a SimpleRetryPolicy of 3 attempts, creates a SpringRetryCircuitBreaker, and runs a call with a fallback returning "Fallback Book".

```java
SpringRetryConfig config = new SpringRetryConfigBuilder("bookService")
    .retryPolicy(new SimpleRetryPolicy(3))
    .build();
CircuitBreaker cb = new SpringRetryCircuitBreaker("bookService", config, null);

String title = cb.run(() -> restTemplate.getForObject("/books/1", String.class),
                      throwable -> "Fallback Book");
```

--------------------------------

### Customize default Resilience4jBulkheadProvider with Bulkhead and ThreadPoolBulkhead

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-resilience4j/bulkhead-pattern-supporting.adoc

Provides a default Bulkhead and ThreadPoolBulkhead configuration for the Resilience4jBulkheadProvider. The example sets maxConcurrentCalls to 4 and core/max thread pool size to 1.

```java
@Bean
public Customizer<Resilience4jBulkheadProvider> defaultBulkheadCustomizer() {
    return provider -> provider.configureDefault(id -> new Resilience4jBulkheadConfigurationBuilder()
        .bulkheadConfig(BulkheadConfig.custom().maxConcurrentCalls(4).build())
        .threadPoolBulkheadConfig(ThreadPoolBulkheadConfig.custom().coreThreadPoolSize(1).maxThreadPoolSize(1).build())
        .build()
);
}
```

--------------------------------

### Checkstyle suppressions file example

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/README.adoc

Example suppression file for Checkstyle. Place it at ${project.root}/src/checkstyle/checkstyle-suppressions.xml to suppress specific rules, such as HideUtilityClassConstructor and LineLengthCheck, for matching files.

```xml
<?xml version="1.0"?>
<!DOCTYPE suppressions PUBLIC
		"-//Puppy Crawl//DTD Suppressions 1.1//EN"
		"https://www.puppycrawl.com/dtds/suppressions_1_1.dtd">
<suppressions>
	<suppress files=".*ConfigServerApplication\.java" checks="HideUtilityClassConstructor"/>
	<suppress files=".*ConfigClientWatch\.java" checks="LineLengthCheck"/>
</suppressions>
```

--------------------------------

### Creating and configuring Resilience4JCircuitBreakerFactory

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-circuit-breaker.md

Example showing how to create a Resilience4JCircuitBreakerFactory, configure it with a circuit breaker config and a time limiter config for the "slow" id, add a customizer for error/success events, and create both a single-id and a grouped circuit breaker.

```java
Resilience4JCircuitBreakerFactory factory = new Resilience4JCircuitBreakerFactory(
        circuitBreakerRegistry, timeLimiterRegistry, null);
factory.configure(builder -> builder
        .circuitBreakerConfig(CircuitBreakerConfig.ofDefaults())
        .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofSeconds(2)).build()),
        "slow");
factory.addCircuitBreakerCustomizer(circuitBreaker -> circuitBreaker.getEventPublisher()
        .onError(normalErrorConsumer).onSuccess(normalSuccessConsumer), "slow");

CircuitBreaker slow = factory.create("slow");
CircuitBreaker grouped = factory.create("backendA", "groupA");
```

--------------------------------

### addBulkheadCustomizer signature and usage

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Method signature and usage example for adding a customizer to a Bulkhead. The customizer is applied per id, materializing the Bulkhead from the registry. Useful for attaching event listeners. Throws IllegalArgumentException if the resolved config lacks a bulkhead config.

```java
public void addBulkheadCustomizer(Customizer<Bulkhead> customizer, String... ids)
```

```java
provider.addBulkheadCustomizer(bulkhead -> bulkhead.getEventPublisher()
    .onCallRejected(rejectedConsumer)
    .onCallFinished(finishedConsumer), "slowBulkhead");
```

--------------------------------

### Build with Maven wrapper

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/README.adoc

Builds the Spring Cloud project source using the Maven wrapper. Requires JDK 17. You can also use a local Maven installation (>=3.3.3) with the `mvn` command, possibly adding `-P spring` for pre-release artifacts.

```bash
$ ./mvnw install
```

--------------------------------

### Slow customizer bean example

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-reactive-circuit-breaker.md

Example bean that configures a 2-second timeout for 'slow' and 'slowflux' circuit breakers and adds custom event listeners for 'normalflux'.

```java
@Bean
public Customizer<ReactiveResilience4JCircuitBreakerFactory> slowCustomizer() {
    return factory -> {
        factory.configure(builder -> builder
            .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofSeconds(2)).build())
            .circuitBreakerConfig(CircuitBreakerConfig.ofDefaults()), "slow", "slowflux");
        factory.addCircuitBreakerCustomizer(circuitBreaker -> circuitBreaker.getEventPublisher()
            .onError(normalFluxErrorConsumer).onSuccess(normalFluxSuccessConsumer), "normalflux");
    };
}
```

--------------------------------

### Spring Cloud Build tools directory structure

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/README.adoc

Shows the layout of the Spring Cloud Build tools directory, with callouts referencing the checkstyle and Intellij configuration files used for IDE setup.

```text
└── src
    ├── checkstyle
    │   └── checkstyle-suppressions.xml <3>
    └── main
        └── resources
            ├── checkstyle-header.txt <2>
            ├── checkstyle.xml <1>
            └── intellij
                ├── Intellij_Project_Defaults.xml <4>
                └── Intellij_Spring_Boot_Java_Conventions.xml <5>
```

--------------------------------

### Configure executor service with context-aware thread pool

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-circuit-breaker.md

Example from the project docs showing how to configure a context-aware scheduled thread pool executor with a core pool size of 5 and set it on the factory.

```java
@Bean
public Customizer<Resilience4JCircuitBreakerFactory> defaultCustomizer() {
    return factory -> {
        ContextAwareScheduledThreadPoolExecutor executor = ContextAwareScheduledThreadPoolExecutor
            .newScheduledThreadPool().corePoolSize(5).build();
        factory.configureExecutorService(executor);
    };
}
```

--------------------------------

### Building a FrameworkRetryConfig with retry policy and timeouts

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Example usage of FrameworkRetryConfigBuilder to create a FrameworkRetryConfig for a bookService circuit breaker, configuring a retry policy with max retries, max duration, and specific exceptions, along with open and reset timeouts.

```java
FrameworkRetryConfig config = new FrameworkRetryConfigBuilder("bookService")
    .retryPolicy(RetryPolicy.withMaxRetries(3)
        .and(RetryPolicy.withMaxDuration(Duration.ofSeconds(5)))
        .forExceptions(IOException.class, TimeoutException.class))
    .openTimeout(Duration.ofSeconds(20))
    .resetTimeout(Duration.ofSeconds(5))
    .build();
```

--------------------------------

### SpringRetryConfigBuilder usage example

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/spring-retry.md

Example usage of SpringRetryConfigBuilder to create a SpringRetryConfig with a SimpleRetryPolicy of 3 attempts, an ExponentialBackOffPolicy, forceRefreshState set to true, and a state classifier that matches IOException.

```java
SpringRetryConfig config = new SpringRetryConfigBuilder("service")
    .retryPolicy(new SimpleRetryPolicy(3))
    .backOffPolicy(new ExponentialBackOffPolicy())
    .forceRefreshState(true)
    .stateClassifier(throwable -> throwable instanceof IOException)
    .build();
```

--------------------------------

### Configure Resilience4J properties in application.yml

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/configuration.md

Example application.yml configuration for Resilience4J circuit breaker properties. Shows global disable-time-limiter, per-group/per-instance overrides, semaphore bulkhead default, thread pool disabling, and micrometer metrics wiring.

```yaml
spring:
  cloud:
    circuitbreaker:
      resilience4j:
        disable-time-limiter: true
        disable-time-limiter-map:
          group1: true
          instanceA: false
          instanceB: true
        enableSemaphoreDefaultBulkhead: true
        disable-thread-pool: false
        micrometer:
          enabled: true
```

--------------------------------

### Using canRetry() to gate a call

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Example usage of canRetry() to check if a retry should be attempted before making a call.

```java
CircuitBreakerRetryPolicy policy = new CircuitBreakerRetryPolicy(RetryPolicy.withDefaults());
if (policy.canRetry()) {
    // attempt the call
}
```

--------------------------------

### Configure and create circuit breakers with FrameworkRetryCircuitBreakerFactory

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Example usage of the factory: configure a specific circuit breaker named 'slow' with a retry policy of 1 max retry, 30-second open timeout, and 10-second reset timeout, then create it. Creating 'other' uses the default configuration.

```java
CircuitBreakerFactory<FrameworkRetryConfig, FrameworkRetryConfigBuilder> factory =
        new FrameworkRetryCircuitBreakerFactory();
factory.configure(builder -> builder
        .retryPolicy(RetryPolicy.withMaxRetries(1))
        .openTimeout(Duration.ofSeconds(30))
        .resetTimeout(Duration.ofSeconds(10))
        .build(), "slow");
CircuitBreaker slow = factory.create("slow");      // specific config
CircuitBreaker other = factory.create("other");    // default config
```

--------------------------------

### Customize ReactiveResilience4jBulkheadProvider with default bulkhead config

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-resilience4j/bulkhead-pattern-supporting.adoc

Configures the ReactiveResilience4jBulkheadProvider with a default bulkhead configuration using a Customizer bean. The example sets maxConcurrentCalls to 4.

```java
@Bean
public Customizer<ReactiveResilience4jBulkheadProvider> reactiveBulkheadCustomizer() {
    return provider -> provider.configureDefault(id -> new Resilience4jBulkheadConfigurationBuilder()
        .bulkheadConfig(BulkheadConfig.custom().maxConcurrentCalls(4).build())
        .build());
}
```

--------------------------------

### Configure specific bulkhead for ReactiveResilience4jBulkheadProvider

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-resilience4j/bulkhead-pattern-supporting.adoc

Adds an individual bulkhead configuration for a specific use case named 'serviceBulkhead' using the ReactiveResilience4jBulkheadProvider. The example sets maxConcurrentCalls to 2.

```java
@Bean
public Customizer<ReactiveResilience4jBulkheadProvider> reactiveSpecificBulkheadCustomizer() {
    return provider -> provider.configure(builder -> {
        builder.bulkheadConfig(BulkheadConfig.custom()
            .maxConcurrentCalls(2)
            .build());
    }, "serviceBulkhead");
}
```

--------------------------------

### Spring Cloud Build tools module structure

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/README.adoc

Shows the layout of the spring-cloud-build-tools module, with checkstyle-suppressions.xml, checkstyle-header.txt, and checkstyle.xml. The callouts indicate default rules, file header setup, and default suppression rules.

```text
└── src
  ├── checkstyle
  │   └── checkstyle-suppressions.xml <3>
  └── main
      └── resources
          ├── checkstyle-header.txt <2>
          └── checkstyle.xml <1>
```

--------------------------------

### Error handling with reactive fallback

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-reactive-circuit-breaker.md

Shows how the fallback can rethrow errors, using TimeoutException as an example.

```java
Mono<String> result = cb.run(request, error -> {
    if (error instanceof TimeoutException) {
        return Mono.just(cachedValue);
    }
    return Mono.error(error); // propagate
});
```

--------------------------------

### Configure group executor service with security context propagation

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-circuit-breaker.md

Example from the project docs showing how to configure a group executor service that propagates security context using DelegatingSecurityContextExecutorService with virtual threads.

```java
@Bean
public Customizer<Resilience4JCircuitBreakerFactory> groupExecutorServiceCustomizer() {
    return factory -> factory.configureGroupExecutorService(
        group -> new DelegatingSecurityContextExecutorService(Executors.newVirtualThreadPerTaskExecutor()));
}
```

--------------------------------

### Error-handling fallback with exception

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Error-handling example where the fallback receives the provoking exception. Logs the error and returns a fallback value.

```java
String result = cb.run(() -> remoteCall(),
    throwable -> {
        log.error("Call failed, applying fallback", throwable);
        return "fallback-value";
    });
```

--------------------------------

### Configuring FrameworkRetryCircuitBreakerFactory with Customizer

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-framework-retry.adoc

Configuration example for FrameworkRetryCircuitBreakerFactory. Defines default and specific circuit breaker configurations using Customizer beans. The default uses retry policy with max retries 3 and backoff, while specific configurations for "slow" and "critical" override retry, open, and reset timeouts.

```java
@Configuration
public class CircuitBreakerConfiguration {

	@Bean
	public Customizer<FrameworkRetryCircuitBreakerFactory> defaultCustomizer() {
		return factory -> {
			// Default configuration for all circuit breakers
			factory.configureDefault(id -> new FrameworkRetryConfigBuilder(id)
				.retryPolicy(RetryPolicy.withMaxRetries(3)
					.withBackoff(Duration.ofMillis(100), 2.0))
				.openTimeout(Duration.ofSeconds(20))
				.resetTimeout(Duration.ofSeconds(5))
				.build());
		};
	}

	@Bean
	public Customizer<FrameworkRetryCircuitBreakerFactory> specificCustomizer() {
		return factory -> {
			// Specific configuration for "slow" circuit breaker
			factory.configure(builder -> builder
				.retryPolicy(RetryPolicy.withMaxRetries(1))
				.openTimeout(Duration.ofSeconds(30))
				.resetTimeout(Duration.ofSeconds(10))
				.build(), "slow");

			// Specific configuration for "critical" circuit breaker
			factory.configure(builder -> builder
				.retryPolicy(RetryPolicy.withMaxRetries(5))
				.openTimeout(Duration.ofMinutes(2))
				.resetTimeout(Duration.ofSeconds(15))
				.build(), "critical");
		};
	}
}
```

--------------------------------

### Customizer bean for reactive bulkhead

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Example bean that customizes the ReactiveResilience4jBulkheadProvider to set a bulkhead config with maxConcurrentCalls(2) for the id "serviceBulkhead".

```java
@Bean
public Customizer<ReactiveResilience4jBulkheadProvider> reactiveSpecificBulkheadCustomizer() {
    return provider -> provider.configure(builder -> {
        builder.bulkheadConfig(BulkheadConfig.custom().maxConcurrentCalls(2).build());
    }, "serviceBulkhead");
}
```

--------------------------------

### Configure reactive circuit breakers with ReactiveResilience4JCircuitBreakerFactory

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-resilience4j/specific-circuit-breaker-configuration.adoc

Reactive example that configures two circuit breakers ("slow" and "slowflux") with a 2-second timeout and default circuit breaker settings, then adds event handlers to the "normalflux" circuit breaker.

```java
@Bean
public Customizer<ReactiveResilience4JCircuitBreakerFactory> slowCustomizer() {
	return factory -> {
		factory.configure(builder -> builder
		.timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofSeconds(2)).build())
		.circuitBreakerConfig(CircuitBreakerConfig.ofDefaults()), "slow", "slowflux");
		factory.addCircuitBreakerCustomizer(circuitBreaker -> circuitBreaker.getEventPublisher()
        	.onError(normalFluxErrorConsumer).onSuccess(normalFluxSuccessConsumer), "normalflux");
     };
}
```

--------------------------------

### addThreadPoolBulkheadCustomizer signature and usage

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Method signature and usage example for adding a customizer to a ThreadPoolBulkhead. Same contract as addBulkheadCustomizer but for ThreadPoolBulkhead from the ThreadPoolBulkheadRegistry. Throws IllegalArgumentException if the resolved config lacks a thread pool bulkhead config.

```java
public void addThreadPoolBulkheadCustomizer(Customizer<ThreadPoolBulkhead> customizer, String... ids)
```

```java
provider.addThreadPoolBulkheadCustomizer(threadPoolBulkhead -> threadPoolBulkhead.getEventPublisher()
    .onCallRejected(rejectedConsumer)
    .onCallFinished(finishedConsumer), "slowThreadPoolBulkhead");
```

--------------------------------

### run() fallback with conditional rethrow

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-circuit-breaker.md

Error handling example where the fallback receives the failure and can rethrow. If the throwable is an IOException, a cached value is returned; otherwise an IllegalStateException is thrown with the original throwable as cause.

```java
String result = cb.run(() -> fragileCall(),
    throwable -> {
        if (throwable instanceof IOException) {
            return cachedValue();
        }
        throw new IllegalStateException("Unrecoverable failure", throwable);
    });
```

--------------------------------

### build method

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Builds and returns a BulkheadConfiguration carrying both the bulkhead and thread pool bulkhead configurations.

```java
public BulkheadConfiguration build()

```

--------------------------------

### ReactiveResilience4JCircuitBreaker

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-reactive-circuit-breaker.md

Documentation for the ReactiveResilience4JCircuitBreaker class, including its constructor, run methods, and usage examples.

```APIDOC
## ReactiveResilience4JCircuitBreaker

### Description
Implements the spring-cloud-commons SPI `ReactiveCircuitBreaker` to protect reactive `Mono` and `Flux` invocations with a Resilience4j circuit breaker, optional bulkhead, and time limiter.

### Constructor

```java
public ReactiveResilience4JCircuitBreaker(String id, String groupName,
		Resilience4JConfigBuilder.Resilience4JCircuitBreakerConfiguration config,
		CircuitBreakerRegistry circuitBreakerRegistry, TimeLimiterRegistry timeLimiterRegistry,
		Optional<Customizer<CircuitBreaker>> circuitBreakerCustomizer,
		@Nullable ReactiveResilience4jBulkheadProvider bulkheadProvider, boolean disableTimeLimiter)
```

#### Parameters
- **id** (`String`) - Required - Circuit breaker id (method/operation name)
- **groupName** (`String`) - Required - Service group name; used as the `group` tag and config fallback
- **config** (`Resilience4JConfigBuilder.Resilience4JCircuitBreakerConfiguration`) - Required - Carries `CircuitBreakerConfig` and `TimeLimiterConfig`
- **circuitBreakerRegistry** (`CircuitBreakerRegistry`) - Required - Registry the circuit breaker is registered in
- **timeLimiterRegistry** (`TimeLimiterRegistry`) - Required - Registry used to resolve/create the `TimeLimiter`
- **circuitBreakerCustomizer** (`Optional<Customizer<CircuitBreaker>>`) - Required - Applied to the resilience4j `CircuitBreaker`
- **bulkheadProvider** (`ReactiveResilience4jBulkheadProvider`) - Optional (`@Nullable`) - Decorates the `Mono`/`Flux` with a bulkhead when present
- **disableTimeLimiter** (`boolean`) - Required - `true` skips time-limit decoration

### `run(Mono<T>, @Nullable Function<Throwable, Mono<T>>)`

```java
@Override
public <T> Mono<T> run(Mono<T> toRun, @Nullable Function<Throwable, Mono<T>> fallback)
```

#### Parameters
- **toRun** (`Mono<T>`) - Required - The reactive invocation to protect
- **fallback** (`Function<Throwable, Mono<T>>`) - Optional (`@Nullable`) - Reactive fallback applied via `onErrorResume`; omitted → errors propagate

#### Returns
- **Mono<T>** - Operator chain: bulkhead (`bulkheadProvider.decorateMono(groupName, tags, toRun)`, `tags = {"group": groupName}`) → `CircuitBreakerOperator.of(circuitBreaker)` via `transform` → `timeout(timeoutDuration)` + `doOnError(TimeoutException.class, t -> circuitBreaker.onError(timeoutDuration.toMillis(), TimeUnit.MILLISECONDS, t))` → `onErrorResume(fallback)` when fallback is non-null.

#### Throws
- **IllegalArgumentException** - From `Assert.notNull(circuitBreakerConfig, "CircuitBreakerConfig must not be null")` inside `buildCircuitBreakerAndTimeLimiter()` if the config lacks a circuit breaker config.

### `run(Flux<T>, @Nullable Function<Throwable, Flux<T>>)`

```java
@Override
public <T> Flux<T> run(Flux<T> toRun, @Nullable Function<Throwable, Flux<T>> fallback)
```

#### Parameters
- **toRun** (`Flux<T>`) - Required - The reactive invocation to protect
- **fallback** (`Function<Throwable, Flux<T>>`) - Optional (`@Nullable`) - Reactive fallback applied via `onErrorResume`; omitted → errors propagate

#### Returns
- **Flux<T>** - Same contract as the `Mono` overload, operating on `Flux<T>` with `bulkheadProvider.decorateFlux(groupName, tags, toRun)`.

### Time limiter resolution (`buildCircuitBreakerAndTimeLimiter`, private)

Resolves `timeLimiterRegistry.find(id)` → `find(groupName)` → `timeLimiterRegistry.timeLimiter(id, timeLimiterConfig, tags)`. When `disableTimeLimiter`, returns `Optional.empty()` and no timeout operator is applied.

### Basic usage

```java
ReactiveResilience4JCircuitBreakerFactory factory = new ReactiveResilience4JCircuitBreakerFactory(
        circuitBreakerRegistry, timeLimiterRegistry, null, new Resilience4JConfigurationProperties());
ReactiveCircuitBreaker cb = factory.create("backendA");

Mono<String> result = cb.run(
        webClient.get().uri("/books/1").retrieve().bodyToMono(String.class),
        throwable -> Mono.just("Fallback Book"));
```

### Error handling

The reactive fallback can decide to rethrow:

```java
Mono<String> result = cb.run(request, error -> {
    if (error instanceof TimeoutException) {
        return Mono.just(cachedValue);
    }
    return Mono.error(error); // propagate
});
```
```

--------------------------------

### Download .editorconfig and create .springformat

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/README.adoc

Downloads the Spring Cloud Build .editorconfig file and creates a .springformat file to enable formatting checks.

```bash
$ curl https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/main/.editorconfig -o .editorconfig
$ touch .springformat
```

--------------------------------

### Basic run() usage with fallback

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-circuit-breaker.md

Basic usage of the run method. Creates a CircuitBreakerFactory with default registries, creates a circuit breaker for "backendA", and runs a protected call with a fallback that returns a constant string.

```java
CircuitBreakerRegistry registry = CircuitBreakerRegistry.ofDefaults();
TimeLimiterRegistry timeLimiterRegistry = TimeLimiterRegistry.ofDefaults();
CircuitBreakerFactory<Resilience4JConfigBuilder.Resilience4JCircuitBreakerConfiguration, Resilience4JConfigBuilder> factory =
        new Resilience4JCircuitBreakerFactory(registry, timeLimiterRegistry, null);

CircuitBreaker cb = factory.create("backendA");
String value = cb.run(() -> restTemplate.getForObject("/api", String.class),
                      throwable -> "fallback");
```

--------------------------------

### Recording success and failure

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Example of recording success or failure around a work call, using recordSuccess() on success and recordFailure(t) on exception.

```java
try {
    doWork();
    policy.recordSuccess();
} catch (Throwable t) {
    policy.recordFailure(t);
}
```

--------------------------------

### build() method

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/spring-retry.md

Builds and returns a SpringRetryConfig with all five fields set: backOffPolicy, id, retryPolicy, forceRefreshState, and stateClassifier.

```java
@Override
public SpringRetryConfig build()
```

--------------------------------

### SpringRetryCircuitBreaker fallback with logging

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/spring-retry.md

Error handling example: the fallback receives the last throwable from the retry context, logs it, and returns a fallback value.

```java
String result = cb.run(() -> fragileCall(), throwable -> {
    log.error("Circuit open or retries exhausted", throwable);
    return fallbackValue;
});
```

--------------------------------

### FrameworkRetryConfigBuilder build() method

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Builds a FrameworkRetryConfig with id set, retryPolicy set, and circuitBreakerRetryPolicy = new CircuitBreakerRetryPolicy(this.retryPolicy, this.openTimeout, this.resetTimeout).

```java
@Override
public FrameworkRetryConfig build()
```

--------------------------------

### ReactiveResilience4jBulkheadProvider constructor

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Constructor that takes a BulkheadRegistry for semaphore bulkheads. Default configuration is id -> new Resilience4jBulkheadConfigurationBuilder().bulkheadConfig(bulkheadRegistry.getDefaultConfig()).build().

```java
public ReactiveResilience4jBulkheadProvider(BulkheadRegistry bulkheadRegistry)
```

--------------------------------

### Reactive fallback with Mono and TimeoutException handling

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/errors.md

Reactive example using Mono and a fallback that handles TimeoutException by returning a cached value, otherwise wraps the error in CircuitBreakerFallbackFailedException.

```java
Mono<String> value = reactiveCb.run(request, error -> {
    if (error instanceof TimeoutException) {
        return Mono.just(cached);
    }
    return Mono.error(new CircuitBreakerFallbackFailedException(error));
});
```

--------------------------------

### bulkheadConfig method

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Method to set the bulkhead configuration. Ignores null values and returns this builder.

```java
public Resilience4jBulkheadConfigurationBuilder bulkheadConfig(@Nullable BulkheadConfig bulkheadConfig)

```

--------------------------------

### resilience4JMeterFilter bean method

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-autoconfiguration.md

Bean method for a MeterFilter that rewrites meters starting with 'resilience4j' and lacking the 'group' tag, adding Tag.of("group", properties.getDefaultGroupTag()).

```java
@Bean
@ConditionalOnProperty(value = "spring.cloud.circuitbreaker.resilience4j.enableGroupMeterFilter",
		havingValue = "true", matchIfMissing = true)
MeterFilter resilience4JMeterFilter(Resilience4JConfigurationProperties properties)
```

--------------------------------

### run(String, Supplier<T>, Function<Throwable, T>, CircuitBreaker, @Nullable TimeLimiter, Map<String, String>)

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Executes a protected invocation with bulkhead, circuit breaker, and optional time limiter.

```APIDOC
## run(String, Supplier<T>, Function<Throwable, T>, CircuitBreaker, @Nullable TimeLimiter, Map<String, String>)

### Description
Runs a protected invocation with bulkhead and optional circuit breaker and time limiter. Returns the result or fallback.

### Method
run

### Signature
`public <T> T run(String id, Supplier<T> toRun, Function<Throwable, T> fallback, CircuitBreaker circuitBreaker, @Nullable TimeLimiter timeLimiter, Map<String, String> tags)`

### Parameters
- **id** (`String`) - Required - Bulkhead id.
- **toRun** (`Supplier<T>`) - Required - Invocation to protect.
- **fallback** (`Function<Throwable, T>`) - Required - Fallback applied on failure.
- **circuitBreaker** (`CircuitBreaker`) - Required - Wraps the time-limited bulkhead call.
- **timeLimiter** (`TimeLimiter`) - Optional (`@Nullable`) - `null` → no time limiting; otherwise `TimeLimiter.decorateFutureSupplier` over a `CompletableFuture` completion stage.
- **tags** (`Map<String, String>`) - Required - Metric tags (e.g. `{"group": groupName}`).

### Returns
- `T` - Result from the decorated call or the fallback. Bulkhead decoration uses `CompletableFuture.supplyAsync(supplier)` for semaphore bulkheads (`Bulkhead.decorateCompletionStage`), or `ThreadPoolBulkhead.decorateSupplier` for thread-pool bulkheads.

### Throws
- `IllegalArgumentException` from `Assert.notNull(...)` if the resolved config lacks the required bulkhead config.
```

--------------------------------

### Add circuit breaker customizer for normalflux

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-circuit-breaker.md

Example from the project docs showing how to add a circuit breaker customizer that registers error and success consumers for the "normalflux" id.

```java
factory.addCircuitBreakerCustomizer(circuitBreaker -> circuitBreaker.getEventPublisher()
        .onError(normalFluxErrorConsumer).onSuccess(normalFluxSuccessConsumer), "normalflux");
```

--------------------------------

### Constructor with registries and properties

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-reactive-circuit-breaker.md

Constructor that initializes the factory with circuit breaker and time limiter registries, an optional bulkhead provider, and configuration properties. Sets default configuration using the registries' default configs.

```java
public ReactiveResilience4JCircuitBreakerFactory(CircuitBreakerRegistry circuitBreakerRegistry,
		TimeLimiterRegistry timeLimiterRegistry, @Nullable ReactiveResilience4jBulkheadProvider bulkheadProvider,
		Resilience4JConfigurationProperties resilience4JConfigurationProperties)
```

--------------------------------

### addBulkheadCustomizer method

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Adds a customizer for Bulkhead instances. Throws IllegalArgumentException if the resolved configuration has no bulkhead config (Assert.notNull(configuration.getBulkheadConfig(), "Bulkhead configuration must not be null")).

```java
public void addBulkheadCustomizer(Consumer<Bulkhead> customizer, String... ids)
```

--------------------------------

### ReactiveResilience4jBulkheadProvider

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Documentation for the ReactiveResilience4jBulkheadProvider class, including its constructor and methods for configuring and decorating reactive streams with bulkhead protection.

```APIDOC
## ReactiveResilience4jBulkheadProvider

### Description
Reactive bulkhead support using only `SemaphoreBulkhead`. Provides methods to configure and decorate reactive streams with bulkhead protection.

### Constructor

#### `ReactiveResilience4jBulkheadProvider(BulkheadRegistry bulkheadRegistry)`

- **Parameters:**
  - `bulkheadRegistry` (BulkheadRegistry) - Required - Registry for semaphore bulkheads
- **Default configuration:** `id -> new Resilience4jBulkheadConfigurationBuilder().bulkheadConfig(bulkheadRegistry.getDefaultConfig()).build()`

### Methods

#### `configureDefault(Function<String, Resilience4jBulkheadConfigurationBuilder.BulkheadConfiguration> defaultConfiguration)`

- **Description:** Sets the default configuration for bulkheads.
- **Parameters:**
  - `defaultConfiguration` (Function<String, Resilience4jBulkheadConfigurationBuilder.BulkheadConfiguration>) - Required - Default configuration function
- **Throws:** `IllegalArgumentException` if `defaultConfiguration` is null.

#### `configure(Consumer<Resilience4jBulkheadConfigurationBuilder> consumer, String... ids)`

- **Description:** Configures bulkheads for specific IDs.
- **Parameters:**
  - `consumer` (Consumer<Resilience4jBulkheadConfigurationBuilder>) - Required - Configuration consumer
  - `ids` (String...) - Optional - Bulkhead IDs to configure
- **Example:**
```java
@Bean
public Customizer<ReactiveResilience4jBulkheadProvider> reactiveSpecificBulkheadCustomizer() {
    return provider -> provider.configure(builder -> {
        builder.bulkheadConfig(BulkheadConfig.custom().maxConcurrentCalls(2).build());
    }, "serviceBulkhead");
}
```

#### `addBulkheadCustomizer(Consumer<Bulkhead> customizer, String... ids)`

- **Description:** Adds a customizer for bulkhead instances.
- **Parameters:**
  - `customizer` (Consumer<Bulkhead>) - Required - Customizer function
  - `ids` (String...) - Optional - Bulkhead IDs to customize
- **Throws:** `IllegalArgumentException` if the bulkhead configuration is null.

#### `getBulkheadRegistry()`

- **Description:** Returns the underlying `BulkheadRegistry`.
- **Returns:** `BulkheadRegistry`

#### `decorateMono(String id, Map<String, String> tags, Mono<T> mono)`

- **Description:** Decorates a `Mono` with bulkhead protection.
- **Type Parameters:** `T`
- **Parameters:**
  - `id` (String) - Required - Bulkhead ID
  - `tags` (Map<String, String>) - Required - Tags for the bulkhead
  - `mono` (Mono<T>) - Required - The Mono to decorate
- **Returns:** `Mono<T>` - Decorated Mono
- **Throws:** `IllegalArgumentException` if the resolved config has no bulkhead config.

#### `decorateFlux(String id, Map<String, String> tags, Flux<T> flux)`

- **Description:** Decorates a `Flux` with bulkhead protection.
- **Type Parameters:** `T`
- **Parameters:**
  - `id` (String) - Required - Bulkhead ID
  - `tags` (Map<String, String>) - Required - Tags for the bulkhead
  - `flux` (Flux<T>) - Required - The Flux to decorate
- **Returns:** `Flux<T>` - Decorated Flux
```

--------------------------------

### addRetryTemplateCustomizers(Customizer, String...) method

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/spring-retry.md

Registers a RetryTemplate customizer for the given circuit breaker ids. The customizer is applied right before execution, for example to register RetryListeners. The ids parameter is required.

```java
public void addRetryTemplateCustomizers(Customizer<RetryTemplate> customizer, String... ids)
```

--------------------------------

### Instances properties configuration

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-resilience4j/circuit-breaker-properties-configuration.adoc

Instance-specific configuration for backendA and backendB. Applied when creating a circuit breaker with the matching instance id.

```yaml
resilience4j.circuitbreaker:
 instances:
     backendA:
         registerHealthIndicator: true
         slidingWindowSize: 100
     backendB:
         registerHealthIndicator: true
         slidingWindowSize: 10
         permittedNumberOfCallsInHalfOpenState: 3
         slidingWindowType: TIME_BASED
         recordFailurePredicate: io.github.robwin.exception.RecordFailurePredicate

resilience4j.timelimiter:
 instances:
     backendA:
         timeoutDuration: 2s
         cancelRunningFuture: true
     backendB:
         timeoutDuration: 1s
         cancelRunningFuture: false
```

--------------------------------

### Bean customizer for slow circuit breaker

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/spring-retry.md

Example bean that customizes the SpringRetryCircuitBreakerFactory by adding a RetryTemplate customizer for the "slow" circuit breaker id. The customizer registers a RetryListener with open, close, and onError callbacks.

```java
@Bean
public Customizer<SpringRetryCircuitBreakerFactory> slowCustomizer() {
    return factory -> factory.addRetryTemplateCustomizers(retryTemplate -> retryTemplate
        .registerListener(new RetryListener() {
            @Override
            public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
                return false;
            }
            @Override
            public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback,
                    Throwable throwable) { }
            @Override
            public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback,
                    Throwable throwable) { }
        }), "slow");
}
```

--------------------------------

### Configure ThreadPoolBulkhead and SemaphoreBulkhead instances

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-resilience4j/bulkhead-properties-configuration.adoc

Configures ThreadPoolBulkhead and SemaphoreBulkhead instances directly via properties. This configuration has higher priority than Java Customizer configuration.

```yaml
resilience4j.thread-pool-bulkhead:
    instances:
        backendA:
            maxThreadPoolSize: 1
            coreThreadPoolSize: 1
resilience4j.bulkhead:
    instances:
        backendB:
            maxConcurrentCalls: 10
```

--------------------------------

### Configure specific bulkhead with Customizer<Resilience4jBulkheadProvider>

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-resilience4j/specific-bulkhead-configuration.adoc

Creates a Customizer bean that configures a Resilience4jBulkheadProvider with a custom BulkheadConfig (maxConcurrentCalls=1) and default ThreadPoolBulkheadConfig for the named bulkhead 'slowBulkhead'.

```java
@Bean
public Customizer<Resilience4jBulkheadProvider> slowBulkheadProviderCustomizer() {
    return provider -> provider.configure(builder -> builder
        .bulkheadConfig(BulkheadConfig.custom().maxConcurrentCalls(1).build())
        .threadPoolBulkheadConfig(ThreadPoolBulkheadConfig.ofDefaults()), "slowBulkhead");
}
```

--------------------------------

### Disable TimeLimiter per group or instance

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-resilience4j/circuit-breaker-properties-configuration.adoc

Disables TimeLimiter for specific groups or instances. Priority order is instance > group > global. In this example, instanceB and group1 are disabled, instanceA is enabled, and others fall back to the global setting.

```yaml
spring:
	cloud:
		circuitbreaker:
			resilience4j:
				disable-time-limiter-map:
					group1: true
					instanceA: false
					instanceB: true
```

--------------------------------

### Provide common bulkhead configuration with configs and baseConfig

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/docs/modules/ROOT/pages/spring-cloud-circuitbreaker-resilience4j/bulkhead-properties-configuration.adoc

Provides common configuration via resilience4j.bulkhead.configs.* and reuses it across multiple bulkheads using baseConfig. This configuration has the lowest priority.

```yaml
resilience4j.bulkhead:
    configs:
        default:
            queueCapacity: 5
        someShared:
            queueCapacity: 10
    instances:
        backendA:
            baseConfig: default
            maxConcurrentCalls: 10
        backendB:
            baseConfig: someShared
```

--------------------------------

### Generate docs site with Antora

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/README.adoc

Generates the documentation site using Antora from the `docs` module. This command processes the README.adoc and copies it to the project root if changes are detected.

```bash
	./mvnw -pl docs -P docs antora:antora
```

--------------------------------

### Configure duplicate-finder-maven-plugin with ignoredClassPatterns and ignoredResourcePatterns

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/README.adoc

Add this configuration to your Maven project's plugin section to define ignored class and resource patterns for the duplicate-finder-maven-plugin. The example ignores the Joda-Time BaseDateTime class, any module-info class, and the changelog.txt resource. This is useful when you need to exclude specific duplicates from the check.

```xml
<build>
    <plugins>
        <plugin>
            <groupId>org.basepom.maven</groupId>
            <artifactId>duplicate-finder-maven-plugin</artifactId>
            <configuration>
                <ignoredClassPatterns>
                    <ignoredClassPattern>org.joda.time.base.BaseDateTime</ignoredClassPattern>
                    <ignoredClassPattern>.*module-info</ignoredClassPattern>
                </ignoredClassPatterns>
                <ignoredResourcePatterns>
                    <ignoredResourcePattern>changelog.txt</ignoredResourcePattern>
                </ignoredResourcePatterns>
            </configuration>
        </plugin>
    </plugins>
</build>
```

--------------------------------

### addBulkheadCustomizer(Customizer<Bulkhead>, String...)

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/resilience4j-bulkhead.md

Method to customize Bulkhead instances from the BulkheadRegistry.

```APIDOC
## addBulkheadCustomizer(Customizer<Bulkhead>, String...)

### Description
Materializes (with `configurations.computeIfAbsent(id, defaultConfiguration)`) and customizes a `Bulkhead` per id from the `BulkheadRegistry` — useful for attaching event listeners.

### Method
addBulkheadCustomizer

### Signature
`public void addBulkheadCustomizer(Customizer<Bulkhead> customizer, String... ids)`

### Parameters
- **customizer** (`Customizer<Bulkhead>`) - Required - Customizer to apply to each bulkhead.
- **ids** (`String...`) - Required - Bulkhead ids to customize.

### Throws
- `IllegalArgumentException` via `Assert.notNull(bulkheadConfig, "Bulkhead configuration must not be null")` when the resolved config lacks a bulkhead config.

### Example
```java
provider.addBulkheadCustomizer(bulkhead -> bulkhead.getEventPublisher()
    .onCallRejected(rejectedConsumer)
    .onCallFinished(finishedConsumer), "slowBulkhead");
```
```

--------------------------------

### FrameworkRetryConfigBuilder class declaration

Source: https://github.com/spring-cloud/spring-cloud-circuitbreaker/blob/main/_autodocs/api-reference/framework-retry.md

Builder class for FrameworkRetryConfig. Defaults: retryPolicy = RetryPolicy.withDefaults() (3 retry attempts with a 1 second delay), openTimeout = Duration.ofSeconds(20), resetTimeout = Duration.ofSeconds(5).

```java
public class FrameworkRetryConfigBuilder implements ConfigBuilder<FrameworkRetryConfig>
```
Tokens:
Raw