return metrics
		}

		metrics = make([]MetricV2, 0, 5)
		metrics = append(metrics, MetricV2{
			Description: getHealLastActivityTimeMD(),
			Value:       float64(time.Since(bgSeq.lastHealActivity)),
		})
		metrics = append(metrics, getObjectsScanned(bgSeq)...)
		metrics = append(metrics, getHealedItems(bgSeq)...)
		metrics = append(metrics, getFailedItems(bgSeq)...)
		return metrics
	})
	return mg

	}

	// Reply with storage information (across nodes in a
	// distributed setup) as json.
	writeSuccessResponseJSON(w, jsonBytes)
}

// MetricsHandler - GET /minio/admin/v3/metrics
// ----------
// Get realtime server metrics
func (a adminAPIHandlers) MetricsHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	objectAPI, _ := validateAdminReq(ctx, w, r, policy.ServerInfoAdminAction)

		return
	}
	z.Rotational, err = dc.ReadBool()
	if err != nil {
		err = msgp.WrapError(err, "Rotational")
		return
	}
	err = z.Metrics.DecodeMsg(dc)
	if err != nil {
		err = msgp.WrapError(err, "Metrics")
		return
	}
	z.Error, err = dc.ReadString()
	if err != nil {
		err = msgp.WrapError(err, "Error")
		return
	}
	return
}

		}
		return rinfo
	}
	defer gr.Close()

	objInfo := gr.ObjInfo

	// make sure we have the latest metadata for metrics calculation
	rinfo.PrevReplicationStatus = objInfo.TargetReplicationStatus(tgt.ARN)

	// Set the encrypted size for SSE-C objects
	var size int64
	if crypto.SSEC.IsEncrypted(objInfo.UserDefined) {

		sm.ReplicaSize += peer.ReplicaSize
		sm.Proxied.Add(madmin.ReplProxyMetric(peer.Proxied))
		for dID, v := range peer.Metrics {
			v2, ok := sm.Metrics[dID]
			if !ok {
				v2 = madmin.SRMetric{}
				v2.Failed.ErrCounts = make(map[string]int)
			}

			// use target endpoint metrics from node which has been up the longest
			if v2.LastOnline.After(v.LastOnline) || v2.LastOnline.IsZero() {

			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidChecksum), r.URL)
			return
		}
		opts.WantChecksum = actualReader.Checksum()

		// Set compression metrics.
		var s2c io.ReadCloser
		wantEncryption := crypto.Requested(r.Header)
		s2c, idxCb = newS2CompressReader(actualReader, actualSize, wantEncryption)
		defer s2c.Close()

		reader = etag.Wrap(s2c, actualReader)