bucketL                                        = "bucket"
	operationL                                     = "operation"
	targetArnL                                     = "targetArn"
)

var (
	bucketReplLastHrFailedBytesMD = NewGaugeMD(bucketReplLastHrFailedBytes,
		"Total number of bytes failed at least once to replicate in the last hour on a bucket",
		bucketL, targetArnL)

							VariableLabels: map[string]string{"bucket": bucket, "targetArn": arn},
						})
						metrics = append(metrics, MetricV2{
							Description:    getRepFailedOperationsLastMinuteMD(bucketMetricNamespace),
							Value:          stat.Failed.LastMinute.Count,
							VariableLabels: map[string]string{"bucket": bucket, "targetArn": arn},
						})
						metrics = append(metrics, MetricV2{

	var wg sync.WaitGroup
	var mu sync.Mutex
	for _, tgtEntry := range dsc.targetsMap {
		if !tgtEntry.Replicate {
			continue
		}
		// if dobj.TargetArn is not empty string, this is a case of specific target being re-synced.
		if dobj.TargetArn != "" && dobj.TargetArn != tgtEntry.Arn {
			continue
		}
		tgtClnt := globalBucketTargetSys.GetRemoteTargetClient(bucket, tgtEntry.Arn)
		if tgtClnt == nil {

			bts, err = z.ExistingObjResync.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "ExistingObjResync")
				return
			}
		case "TargetArn":
			z.TargetArn, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TargetArn")
				return
			}
		case "TargetStatuses":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {

	OpType               replication.Type
	EventType            string
	RetryCount           uint32
	ResetID              string
	Dsc                  ReplicateDecision
	ExistingObjResync    ResyncDecision
	TargetArn            string
	TargetStatuses       map[string]replication.StatusType
	TargetPurgeStatuses  map[string]VersionPurgeStatusType
	ReplicationTimestamp time.Time
	Checksum             []byte
}

		return
	}

	tgtArns := config.FilterTargetArns(
		replication.ObjectOpts{
			OpType:    replication.ResyncReplicationType,
			TargetArn: arn,
		})

	if len(tgtArns) == 0 {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrBadRequest, InvalidArgument{
			Bucket: bucket,

| `minio_bucket_replication_latency_ms`                               | Replication latency on a bucket in milliseconds. <br><br>Type: gauge                                            | `bucket`, `operation`, `range`, `targetArn`, `server` |

		if targetsPtr, _ := globalBucketTargetSys.ListBucketTargets(ctx, bucket); targetsPtr != nil {
			targets = targetsPtr.Targets
		}
		targetARN := ""
		var updateTgt, updateBW bool
		var targetToUpdate madmin.BucketTarget
		for _, target := range targets {
			if target.Arn == ruleARN {
				targetARN = ruleARN
				updateBW = peer.DefaultBandwidth.Limit != 0 && target.BandwidthLimit == 0