// Add  a new duration data
func (l *lastMinuteLatency) addAll(sec int64, a AccElem) {
	l.forwardTo(sec)
	winIdx := sec % 60
	l.Totals[winIdx].merge(a)
	l.LastSec = sec
}

// Merge all recorded latencies of last minute into one
func (l *lastMinuteLatency) getTotal() AccElem {
	var res AccElem
	sec := time.Now().Unix()
	l.forwardTo(sec)
	for _, elem := range l.Totals[:] {
		res.merge(elem)
	}
	return res

		in a runnable state before actually running. Bucket counts
		increase monotonically.

	/sched/pauses/stopping/gc:seconds
		Distribution of individual GC-related stop-the-world stopping
		latencies. This is the time it takes from deciding to stop the
		world until all Ps are stopped. This is a subset of the total
		GC-related stop-the-world time (/sched/pauses/total/gc:seconds).

		Kind:        KindFloat64Histogram,
		Cumulative:  true,
	},
	{
		Name:        "/sched/pauses/stopping/gc:seconds",

			elapsed:            time.Duration(10) * time.Second,
			metrics: []string{
				"apiserver_storage_transformation_duration_seconds",
			},
			want: `
			# HELP apiserver_storage_transformation_duration_seconds [ALPHA] Latencies in seconds of value transformation operations.
			# TYPE apiserver_storage_transformation_duration_seconds histogram

		uerr = errors.Unwrap(leafErr)
		depth++
		if depth == unwrapErrsDepth {
			// If we have reached enough depth we
			// do not further recurse down, this
			// is done to avoid any unnecessary
			// latencies this might bring.
			break
		}
	}
	if uerr == nil {
		leafErr = err
	}
	return leafErr
}

// One log message per error.

	m.Set(driveAvailabilityErrorsTotal, float64(disk.Metrics.TotalErrorsAvailability), labels...)
	m.Set(driveWaitingIO, float64(disk.Metrics.TotalWaiting), labels...)

	// Append the api label for the drive API latencies.
	labels = append(labels, "api", "")
	lastIdx := len(labels) - 1
	for apiName, latency := range disk.Metrics.LastMinute {
		labels[lastIdx] = "storage." + apiName

// heuristic, they may be put into the same cluster and it can introduce
// artificial dependencies and incur great performance loss.  In this example,
// Node_Y becomes dependent on IteratorGetNext and the latencies add up if
// Node_X and Node_Y are in the same cluster.
//
// IteratorGetNext -> Node_X -> Stage
//
// Unstage -> Node_Y
//
Status ClusterScopingPassImpl::ScopingForPipelineStages() {

	currentPaths sync.Map

	cycleInfoMu sync.Mutex
	cycleInfo   *currentScannerCycle
}

var globalScannerMetrics scannerMetrics

const (
	// START Realtime metrics, that only to records
	// last minute latencies and total operation count.
	scannerMetricReadMetadata scannerMetric = iota
	scannerMetricCheckMissing
	scannerMetricSaveUsage
	scannerMetricApplyAll
	scannerMetricApplyVersion
	scannerMetricTierObjSweep

			Help: "Etcd request latency in seconds for each operation and object type.",
			// Etcd request latency in seconds for each operation and object type.
			// This metric is used for verifying etcd api call latencies SLO
			// keep consistent with apiserver metric 'requestLatencies' in
			// staging/src/k8s.io/apiserver/pkg/endpoints/metrics/metrics.go
			Buckets: []float64{0.005, 0.025, 0.05, 0.1, 0.2, 0.4, 0.6, 0.8, 1.0, 1.25, 1.5, 2, 3,

							"grpc_type": true,
							"grpc_code": true,
						})
						return mf, nil
					},
				},
			},

			// etcd 3.0 metric format for grpc request latencies,
			// rewritten to the etcd 3.1+ format.
			"etcd_grpc_unary_requests_duration_seconds": {
				rewriters: []rewriteFunc{
					func(mf *dto.MetricFamily) (*dto.MetricFamily, error) {
						mf = deepCopyMetricFamily(mf)