int failures = consecutiveFailures.incrementAndGet();
            if (failures >= failureThreshold) {
                if (state.compareAndSet(State.CLOSED, State.OPEN)) {
                    stateChangeTime.set(System.currentTimeMillis());
                    log.warn("Circuit breaker {} opened after {} consecutive failures", name, failures);
                }
            }
        }
    }

    /**

                    // Expected
                }
            }

            // Circuit should be OPEN after 3 failures
            assertEquals(State.OPEN, customCb.getState(), "Circuit should be OPEN after regular failures");
            assertEquals(3, customCb.getFailureCount(), "Should have 3 failures");

            // Reset for custom predicate test
            customCb.reset();

        int failures = getFailureCount(handle);

        // Base interval starts at 1 second, increases with failures
        // Max interval is 30 seconds for inactive directories
        return Math.min(MAX_POLL_INTERVAL, BASE_POLL_INTERVAL + (failures * 2000));
    }

    /**
     * Get failure count for a handle
     *
     * @param handle notification handle

            log.warn("[{}] Failure in HALF_OPEN state, reopening circuit: {}", name, e.getMessage());
            transitionTo(State.OPEN);
        } else if (currentState == State.CLOSED) {
            int failures = failureCount.incrementAndGet();
            int currentThreshold = this.failureThreshold;
            log.debug("[{}] Failure in CLOSED state ({}/{}): {}", name, failures, currentThreshold, e.getMessage());

                    failures.add(lines.joinToString("\n"))
                }
            }
        }

        if (shouldFix) {
            // Only write the mutations if there were no failures
            if (failures.isNotEmpty()) {
                val lines = listOf("""

| `minio_cluster_replication_proxied_head_requests_failures` | (_Site Replication Only_)Number of failures in HEAD requests proxied to replication target                          |

                    // Exponential backoff on errors: max 30 seconds, based on consecutive failures
                    try {
                        int failures = Math.min(registration.getHeartbeatFailures(), MAX_FAILURE_LIMIT);
                        long backoffDelay = Math.min(MAX_ERROR_BACKOFF, BASE_ERROR_DELAY * (1L << failures));
                        Thread.sleep(backoffDelay);

    }

    /**
     * Safely registers a class with Kryo, logging any registration failures at WARN level.
     * <p>
     * This method catches exceptions for individual class registrations to ensure
     * that a failure to register one class doesn't prevent other classes from being registered.
     * Registration failures are logged at WARN level since they may cause serialization errors later.
     * </p>
     *

    @Test
    @DisplayName("Test mixed success and failure pattern")
    void testMixedPattern() throws Exception {
        // Success
        circuitBreaker.call(() -> "success");

        // Two failures (not enough to open)
        for (int i = 0; i < 2; i++) {
            try {
                circuitBreaker.call(() -> {
                    throw new RuntimeException("Test failure");
                });

                            // Only record failure/success if the attempt was allowed
                            if (j % 2 == 0) {
                                concurrentLimiter.recordFailure("user" + threadId, "192.168.2." + threadId);
                                localFailures++;
                                // Prevent lockout by resetting after 3 failures
                                if (localFailures >= 3) {