public void formatRate(MessageBuilder builder, double rate) {
        // Handle invalid rates gracefully (including negative values)
        if (Double.isNaN(rate) || Double.isInfinite(rate) || rate < 0) {
            builder.append("? B/s");
            return;
        }

        ScaleUnit unit = ScaleUnit.getScaleUnit(Math.round(rate));
        double scaledRate = rate / unit.bytes();

          },
          "exemplar": true,
          "expr": "sum by (server) (rate(minio_s3_traffic_received_bytes{job=~\"$scrape_jobs\"}[$__rate_interval]))",
          "interval": "1m",
          "intervalFactor": 2,
          "legendFormat": "Data Received [{{server}}]",
          "refId": "A"
        }
      ],
      "title": "S3 API Ingress Rate ",
      "type": "timeseries"
    },
    {
      "datasource": {

errors.crud_failed_to_create_instance = Impossibile creare nuovi dati.
errors.crud_failed_to_create_crud_table = Impossibile creare nuovi dati. ({0})
errors.crud_failed_to_update_crud_table=Impossibile aggiornare i dati. ({0})
errors.crud_failed_to_delete_crud_table=Impossibile eliminare i dati. ({0})
errors.crud_could_not_find_crud_table = Dati {0} non trovati.
errors.could_not_find_backup_index=Impossibile trovare l'indice di backup.

class TracingTensorHandle : public AbstractTensorHandle {
 protected:
  explicit TracingTensorHandle(AbstractTensorHandleKind kind)
      : AbstractTensorHandle(kind) {}

 public:
  // For LLVM style RTTI.
  static bool classof(const AbstractTensorHandle* ptr) {
    return ptr->getKind() == kGraph || ptr->getKind() == kMlir;
  }
};

// An abstract operation describes an operation by its type, name, and

            }
            sendBlockedResponse(httpResponse);
            return;
        }

        // Check rate limit
        if (!rateLimitHelper.allowRequest(clientIp)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Rate limit exceeded: clientIp={}", clientIp);
            }
            sendRateLimitResponse(httpResponse, rateLimitHelper.getRetryAfterSeconds());

		"Average replication data transfer rate in bytes/sec")
	replicationCurrentActiveWorkersMD = NewGaugeMD(replicationCurrentActiveWorkers,
		"Total number of active replication workers")
	replicationCurrentDataTransferRateMD = NewGaugeMD(replicationCurrentDataTransferRate,
		"Current replication data transfer rate in bytes/sec")
	replicationLastMinuteQueuedBytesMD = NewGaugeMD(replicationLastMinuteQueuedBytes,

        if (logger.isInfoEnabled()) {
            logger.info("RateLimitHelper initialized: windowMs={}, blockDurationMs={}", windowMs, blockDurationMs);
        }
    }

    /**
     * Check if rate limiting is enabled.
     * @return true if rate limiting is enabled
     */
    public boolean isEnabled() {
        return ComponentUtil.getFessConfig().isRateLimitEnabled();
    }

    /**

package bandwidth

//go:generate msgp -file=$GOFILE -unexported

import (
	"context"
	"slices"
	"sync"
	"time"

	"golang.org/x/time/rate"
)

//msgp:ignore bucketThrottle Monitor

type bucketThrottle struct {
	*rate.Limiter
	NodeBandwidthPerSec int64
}

// Monitor holds the state of the global bucket monitor
type Monitor struct {
	tlock sync.RWMutex // mutex for bucket throttling

#                                                                           Rate Limiting
#                                                                           ==============
# Whether rate limiting is enabled.
rate.limit.enabled=false
# Maximum number of requests allowed per window.
rate.limit.requests.per.window=100
# Window size in milliseconds.
rate.limit.window.ms=60000
# Duration in milliseconds to block IP when limit exceeded.

  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);