err = dc.Skip()
					if err != nil {
						err = msgp.WrapError(err, "QueueStats")
						return
					}
				}
			}
		case "ProxyStats":
			err = z.ProxyStats.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "ProxyStats")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}

	ReplicationStats BucketReplicationStats `json:"currStats"`  // current replication stats since cluster startup
	QueueStats       ReplicationQueueStats  `json:"queueStats"` // replication queue stats
	ProxyStats       ProxyMetric            `json:"proxyStats"`
}

// BucketReplicationStats represents inline replication statistics
// such as pending, failed and completed bytes in total for a bucket
type BucketReplicationStats struct {

						Value:          float64(s.ProxyStats.GetTotal),
						VariableLabels: map[string]string{"bucket": bucket},
					})
					metrics = append(metrics, MetricV2{
						Description:    getClusterReplProxiedHeadOperationsMD(bucketMetricNamespace),
						Value:          float64(s.ProxyStats.HeadTotal),
						VariableLabels: map[string]string{"bucket": bucket},
					})

		Timestamp: UTCNow(),
	}
	for k, replicationStats := range replicationStatsList {
		bucketStatsMap.Stats[k] = BucketStats{
			ReplicationStats: replicationStats,
			ProxyStats:       globalReplicationStats.Load().getProxyStats(k),
		}
	}

	replicationStats = append(replicationStats, bucketStatsMap)
	return replicationStats
}

	bucketStatsMap := make(map[string]BucketStats, len(replicationStats))
	for k, v := range replicationStats {
		bucketStatsMap[k] = BucketStats{
			ReplicationStats: v,
			ProxyStats:       globalReplicationStats.Load().getProxyStats(k),
		}
	}
	return &BucketStatsMap{Stats: bucketStatsMap, Timestamp: time.Now()}, nil
}

			proxytgts := getProxyTargets(ctx, bucket, object, opts)
			if !proxytgts.Empty() {
				globalReplicationStats.Load().incProxy(bucket, getObjectAPI, false)
				// proxy to replication target if active-active replication is in place.
				reader, proxy, perr = proxyGetToReplicationTarget(ctx, bucket, object, rs, r.Header, opts, proxytgts)
				if perr != nil {