bucketStats.updateHTTPStats(bucketName, "GetObject", recorder)
				_ = bucketStats.load(bucketName)
			}
		}(i)
	}
	wg.Wait()

	stats := bucketStats.load("test-bucket")
	if stats.totalS3Requests == nil {
		t.Error("Expected bucket stats to be initialized")
	}
	t.Logf("Bucket HTTP stats race test passed")

			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{

			got = m.GetReport(SelectBuckets())
			if !reflect.DeepEqual(got.BucketStats, tt.want2.BucketStats) {
				t.Errorf("GetReport() = %v, want %v", got.BucketStats, tt.want2.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()

		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.

		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

	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

	}
}

func BenchmarkMarshalMsgBucketStats(b *testing.B) {
	v := BucketStats{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgBucketStats(b *testing.B) {
	v := BucketStats{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()

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