}

    /**
     * Increment error counter
     */
    public void incrementErrors() {
        errors.incrementAndGet();
    }

    /**
     * Get error rate (errors / total requests)
     *
     * @return error rate between 0.0 and 1.0
     */
    public double getErrorRate() {
        long total = requestsSent.get();
        if (total == 0)
            return 0.0;

    @Test
    void testFormatRateEdgeCases() {
        FileSizeFormat format = new FileSizeFormat();

        // Test zero rate
        MessageBuilder builder = new DefaultMessageBuilder();
        format.formatRate(builder, 0.0);
        assertEquals("0.0 B/s", builder.build());

        // Test rate at exactly 1000 (1 kB/s)
        builder = new DefaultMessageBuilder();
        format.formatRate(builder, 1000.0);

  int maximumSize;

  @Param("5000")
  int distinctKeys;

  @Param("4")
  int segments;

  // 1 means uniform likelihood of keys; higher means some keys are more popular
  // tweak this to control hit rate
  @Param("2.5")
  double concentration;

  Random random = new Random();

  LoadingCache<Integer, Integer> cache;

  int max;

  static AtomicLong requests = new AtomicLong(0);

└─────┴─────────────────────────────────┴──────────────────────────────────┴────────┘
```

### Decommissioning status

```
λ mc admin decommission status alias/ http://minio{1...2}/data{1...4}
Decommissioning rate at 36 MiB/sec [4 TiB/50 TiB]
Started: 1 minute ago
```

Once it is **Complete**

```
λ mc admin decommission status alias/ http://minio{1...2}/data{1...4}

            long avgResponseTime = metrics.getAverageResponseTime();

            // Adjust threshold based on failure rate and response time trends
            int currentThreshold = this.failureThreshold;
            int newThreshold = currentThreshold;

            // If failure rate is high but response time is normal, be more lenient
            if (failureRate > 0.5 && avgResponseTime < 5000) {

        assertTrue(primaryScore > baseScore);

        // High error rate should reduce score
        channelInfo.setState(ChannelState.ESTABLISHED);
        channelInfo.setPrimary(false);
        for (int i = 0; i < 20; i++) {
            channelInfo.incrementRequestsSent();
            channelInfo.incrementErrors(); // 100% error rate
        }
        int highErrorScore = channelInfo.getScore();

    }

    /**
     * Configure rate limiting
     *
     * @param windowMs time window in milliseconds
     * @param maxEvents maximum events per window
     */
    public void setRateLimit(long windowMs, int maxEvents) {
        this.rateLimitWindow = windowMs;
        this.maxEventsPerWindow = maxEvents;
        log.info("Rate limiting set to {} events per {} ms", maxEvents, windowMs);
    }

            }
        }

        // If we've had many errors, consider fallback
        double errorRate = statistics.getErrorRate();
        if (errorRate > 0.1) { // More than 10% error rate
            log.warn("High RDMA error rate ({:.1f}%), TCP fallback recommended", errorRate * 100);
            return true;
        }

        return false;
    }

    /**

     * @return active memory region count
     */
    public long getMemoryRegionsActive() {
        return memoryRegionsActive.get();
    }

    /**
     * Calculate error rate as percentage of total operations
     *
     * @return error rate (0.0 to 1.0)
     */
    public double getErrorRate() {
        long total = rdmaReads.get() + rdmaWrites.get() + rdmaSends.get() + rdmaReceives.get();
        if (total == 0) {

	ReplicatedCount int64 `json:"replicationCount"`
	// Replication latency information
	Latency ReplicationLatency `json:"replicationLatency"`
	// transfer rate for large uploads
	XferRateLrg *XferStats `json:"largeTransferRate" msg:"lt"`
	// transfer rate for small uploads
	XferRateSml *XferStats `json:"smallTransferRate" msg:"st"`
	// Endpoint is the replication target endpoint
	Endpoint string `json:"-"`