bucketStat, ok := peerBucketStats.Stats[bucket]
			if !ok {
				continue
			}
			bucketStats[i] = bucketStat
		}
		bucketsReplicationStats[bucket] = r.calculateBucketReplicationStats(bucket, bucketStats)
	}
	return bucketsReplicationStats
}

func (r *ReplicationStats) calculateBucketReplicationStats(bucket string, bucketStats []BucketStats) (bs BucketStats) {
	if r == nil {
		bs = BucketStats{

	srProxyStats ProxyMetric
	bucketStats  map[string]ProxyMetric
	sync.RWMutex // mutex for proxy stats
}

func newProxyStatsCache() proxyStatsCache {
	return proxyStatsCache{
		bucketStats: make(map[string]ProxyMetric),
	}
}

func (p *proxyStatsCache) inc(bucket string, api replProxyAPI, isErr bool) {
	p.Lock()
	defer p.Unlock()
	v, ok := p.bucketStats[bucket]
	if !ok {
		v = ProxyMetric{}

	CurrentBandwidthInBytesPerSecond float64 `json:"currentBandwidth"`
}

// BucketBandwidthReport captures the details for all buckets.
type BucketBandwidthReport struct {
	BucketStats map[BucketOptions]Details `json:"bucketStats,omitempty"`
}

// GetReport gets the report for all bucket bandwidth details.
func (m *Monitor) GetReport(selectBucket SelectionFunction) *BucketBandwidthReport {
	m.mlock.RLock()

	s.RLock()
	defer s.RUnlock()

	if len(s.stats) == 0 {
		return nil
	}

	bucketStats := make(map[string]inOutBytes, len(s.stats))
	for k, v := range s.stats {
		bucketStats[k] = inOutBytes{
			In:  v.s3InputBytes,
			Out: v.s3OutputBytes,
		}
	}
	return bucketStats
}

// Return S3 total input/output bytes for each

		l.Totals[idx] = AccElem{}
		l.LastMin++
	}
}

// BucketStatsMap captures bucket statistics for all buckets
type BucketStatsMap struct {
	Stats     map[string]BucketStats
	Timestamp time.Time
}

// BucketStats bucket statistics
type BucketStats struct {
	Uptime           int64                  `json:"uptime"`
	ReplicationStats BucketReplicationStats `json:"currStats"`  // current replication stats since cluster startup

		bucketStats = append(bucketStats, BucketStats{
			ReplicationStats: st.Get(bucketName),
			QueueStats:       ReplicationQueueStats{Nodes: []ReplQNodeStats{st.getNodeQueueStats(bucketName)}},
			ProxyStats:       st.getProxyStats(bucketName),
		})
	}
	return bucketStats
}

// GetClusterSiteMetrics - calls GetClusterSiteMetrics call on all peers for a cluster statistics view.

				return
			}
			if z.Stats == nil {
				z.Stats = make(map[string]BucketStats, zb0002)
			} else if len(z.Stats) > 0 {
				for key := range z.Stats {
					delete(z.Stats, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 BucketStats
				za0001, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Stats")

	getBucketStatsRPC              = grid.NewSingleHandler[*grid.MSS, *BucketStats](grid.HandlerGetBucketStats, grid.NewMSS, func() *BucketStats { return &BucketStats{} })
	getCPUsHandler                 = grid.NewSingleHandler[*grid.MSS, *grid.JSON[madmin.CPUs]](grid.HandlerGetCPUs, grid.NewMSS, madminCPUs.NewJSON)

		}
	}

	for i, sri := range sris {
		for b := range allBuckets {
			if _, ok := bucketStats[b]; !ok {
				bucketStats[b] = make([]srBucketMetaInfo, numSites)
			}
			si, ok := sri.Buckets[b]
			if !ok {
				si = madmin.SRBucketInfo{Bucket: b}
			}
			bucketStats[b][i] = srBucketMetaInfo{SRBucketInfo: si, DeploymentID: sri.DeploymentID}
		}

		for pname := range allPolicies {

	enc := json.NewEncoder(w)
	stats := globalReplicationStats.Load().getLatestReplicationStats(bucket)
	bwRpt := globalNotificationSys.GetBandwidthReports(ctx, bucket)
	bwMap := bwRpt.BucketStats
	for arn, st := range stats.ReplicationStats.Stats {
		for opts, bw := range bwMap {
			if opts.ReplicationARN != "" && opts.ReplicationARN == arn {
				st.BandWidthLimitInBytesPerSecond = bw.LimitInBytesPerSecond