Adam Murdoch <******@****.***> <******@****.***>
Adrian Kelly <******@****.***> <******@****.***>
Benjamin Muschko <******@****.***> <******@****.***>
Cedric Champeau <cedric@gradle.com>
Cedric Champeau <cedric@gradle.com> <cedric******@****.***>
Cedric Champeau <cedric@gradle.com> <cedric******@****.***>
Daz DeBoer <******@****.***>
Daz DeBoer <******@****.***> <******@****.***>

		return true
	})
	return i
}

// lifetime returns the lifetime count of the specified metric.
func (p *scannerMetrics) lifetime(m scannerMetric) uint64 {
	if m >= scannerMetricLast {
		return 0
	}
	val := atomic.LoadUint64(&p.operations[m])
	return val
}

// lastMinute returns the last minute statistics of a metric.
// m should be < scannerMetricLastRealtime

apiVersion: release-notes/v2
kind: feature
area: telemetry
releaseNotes:
- |
  **Added** a new metric (`istiod_managed_clusters`) to `istiod` to track the number of clusters managed by an

apiVersion: release-notes/v2
kind: feature
area: telemetry
releaseNotes:
- |

		if mf.GetName() == name {
			for _, metric := range mf.GetMetric() {
				if testutil.LabelsMatch(metric, expectedLabels) {
					gotLabelCount := len(metric.GetLabel())
					wantLabelCount := len(expectedLabels)
					if wantLabelCount != gotLabelCount {
						t.Errorf("Got metric with %d labels, but wanted %d labels. Wanted %#+v for %s",
							gotLabelCount, wantLabelCount, expectedLabels, metric.String())
						continue
					}
				}

}

// Dec decreases a metric counter by 1, in an atomic way
func (r *PendingPodsRecorder) Dec() {
	r.recorder.Dec()
}

// Clear set a metric counter to 0, in an atomic way
func (r *PendingPodsRecorder) Clear() {
	r.recorder.Set(float64(0))
}

// metric is the data structure passed in the buffer channel between the main framework thread
// and the metricsRecorder goroutine.
type metric struct {

	)

	if metric.Available != nil {
		available = uint64(metric.Available.Value())
	}
	if metric.Capacity != nil {
		capacity = uint64(metric.Capacity.Value())
	}
	if metric.Used != nil {
		used = uint64(metric.Used.Value())
	}
	if metric.Inodes != nil {
		inodes = uint64(metric.Inodes.Value())
	}
	if metric.InodesFree != nil {

func (m *MetricsTest) Metrics() []Metric {
	m.t.Helper()
	res, err := m.reg.Gather()
	if err != nil {
		m.t.Fatal(err)
	}
	metrics := []Metric{}
	for _, metric := range res {
		if len(metric.Metric) == 0 {
			m.t.Logf("%v: no rows", *metric.Name)
		}
		for _, row := range metric.Metric {
			m := Metric{Name: *metric.Name, Labels: map[string]string{}, Value: display(row)}

	name string
}

// Decrement implements Metric
func (dm *disabledMetric) Decrement() {}

// Increment implements Metric
func (dm *disabledMetric) Increment() {}

// Name implements Metric
func (dm *disabledMetric) Name() string {
	return dm.name
}

// Record implements Metric
func (dm *disabledMetric) Record(value float64) {}

// RecordInt implements Metric
func (dm *disabledMetric) RecordInt(value int64) {}

	return v.kind
}

// Uint64 returns the internal uint64 value for the metric.
//
// If v.Kind() != KindUint64, this method panics.
func (v Value) Uint64() uint64 {
	if v.kind != KindUint64 {
		panic("called Uint64 on non-uint64 metric value")
	}
	return v.scalar
}

// Float64 returns the internal float64 value for the metric.
//
// If v.Kind() != KindFloat64, this method panics.