totalBackpressureRejections.incrementAndGet();
                throw new CIFSException("Circuit breaker '" + name + "' rejected request due to backpressure");
            }
        }

        long startTime = System.nanoTime();
        boolean semaphoreAcquired = backpressureEnabled && requestSemaphore != null;

        try {
            activeRequests.incrementAndGet();

        Consumer<String> countingConsumer = line -> {
            if (line.startsWith("Thread:")) {
                threadCount.incrementAndGet();
            } else if (line.startsWith("\tat ")) {
                stackTraceCount.incrementAndGet();
            }
        };

        ThreadDumpUtil.processThreadDump(countingConsumer);

        // Verify that multiple threads were processed

        totalValidations.incrementAndGet();

        if (buffer == null) {
            failedValidations.incrementAndGet();
            throw new SmbException("Response buffer is null");
        }

        if (buffer.length < expectedSize) {
            failedValidations.incrementAndGet();
            bufferOverflowsPrevented.incrementAndGet();

                            // Some successes
                            breaker.call(() -> "success");
                            successCount.incrementAndGet();
                        }
                    } catch (Exception e) {
                        failureCount.incrementAndGet();
                    }
                }
            });
        }

        // Start all threads
        for (Thread t : threads) {

     * Record an RDMA operation error
     */
    public void recordError() {
        operationErrors.incrementAndGet();
    }

    /**
     * Record a new RDMA connection creation
     */
    public void recordConnectionCreated() {
        connectionsCreated.incrementAndGet();
        connectionsActive.incrementAndGet();
    }

    /**
     * Record RDMA connection closure
     */

            if (ip.isBlocked()) {
                if (ip.getBlockExpiry().isAfter(Instant.now())) {
                    totalAttemptsBlocked.incrementAndGet();
                    totalIpsBlocked.incrementAndGet();
                    log.warn("IP {} is blocked due to excessive attempts", sourceIp);
                    return false;
                } else {
                    // Block expired, reset

    
    public void recordRdmaRead(int bytes) {
        rdmaReads.incrementAndGet();
        bytesTransferred.addAndGet(bytes);
    }
    
    public void recordRdmaWrite(int bytes) {
        rdmaWrites.incrementAndGet();
        bytesTransferred.addAndGet(bytes);
    }
    
    public void recordError() {
        operationErrors.incrementAndGet();
    }
    
    public double getErrorRate() {

            @Override
            public void store(DataStoreParams paramMap, Map<String, Object> dataMap) {
                assertNotNull(paramMap);
                assertNotNull(dataMap);
                docSize.incrementAndGet();
                execTime.addAndGet(100);
            }

            @Override
            public long getDocumentSize() {
                return docSize.get();
            }

            @Override

     */
    public <T> T call(Callable<T> callable, Callable<T> fallback) throws Exception {
        totalCalls.incrementAndGet();

        State currentState = evaluateState();

        if (currentState == State.OPEN) {
            rejectedCalls.incrementAndGet();
            if (fallback != null) {
                log.debug("Circuit breaker {} is open, using fallback", name);

                    if (shouldRelease) {
                        session.release();
                        releaseCount.incrementAndGet();
                    } else {
                        session.acquire();
                        acquireCount.incrementAndGet();
                    }

                } catch (Exception e) {
                    // Ignore expected exceptions from over-release