scannerMetricCleanAbandoned
	scannerMetricApplyNonCurrent
	scannerMetricHealAbandonedVersion

	// START Trace metrics:
	scannerMetricStartTrace
	scannerMetricScanObject // Scan object. All operations included.
	scannerMetricHealAbandonedObject

	// END realtime metrics:
	scannerMetricLastRealtime

	// Trace only metrics:
	scannerMetricScanFolder      // Scan a folder on disk, recursively.

	}

	key := getResourceKey(name, labels)
	metric, found := subsysMetrics[key]
	if !found {
		metric = ResourceMetric{
			Name:   name,
			Labels: labels,
		}
	}

	if isCumulative {
		metric.Current = val - metric.Cumulative
		metric.Cumulative = val
	} else {
		metric.Current = val
	}

	if metric.Current > metric.Max {
		metric.Max = val
	}

	metric.Sum += metric.Current

}

// MetricsGroup - represents a group of metrics. It includes a `MetricsLoaderFn`
// function that provides a way to load the metrics from the system. The metrics
// are cached and refreshed after a given timeout.
//
// For metrics with a `bucket` dimension, a list of buckets argument is required
// to collect the metrics.
//
// It implements the prometheus.Collector interface for metric groups without a

			t = &m
		}

		mx[Total] = *t
		metric := SRMetric{
			ReplicatedSize:  v.ReplicatedSize,
			ReplicatedCount: v.ReplicatedCount,
			DeploymentID:    dID,
			Failed:          v.Failed.toMetric(),
			XferStats:       mx,
		}
		epHealth, ok := epMap[v.Endpoint]
		if ok {
			metric.Endpoint = epHealth.Endpoint
			metric.TotalDowntime = epHealth.offlineDuration
			metric.LastOnline = epHealth.lastOnline

			for _, d := range mg.Descriptors {
				labels := slices.Clone(d.VariableLabels)
				labels = append(labels, commonLabels...)
				metric := metricDisplay{
					Name:   mg.MetricFQN(d.Name),
					Help:   d.Help,
					Type:   d.Type.String(),
					Labels: labels,
				}
				metrics = append(metrics, metric)
			}
		}
	}

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

			metric := MetricV2{
				Description:    desc,
				VariableLabels: labels,
				Value:          float64(b.GetCumulativeCount()),
			}
			if limitBuckets && labels["bucket"] != "" {
				buckets[labels["bucket"]] = append(buckets[labels["bucket"]], metric)
			} else {
				metrics = append(metrics, metric)
			}
		}
		// add metrics with +Inf label

	desc *prometheus.Desc
}

// Describe sends the super-set of all possible descriptors of metrics
func (c *minioCollector) Describe(ch chan<- *prometheus.Desc) {
	ch <- c.desc
}

// Collect is called by the Prometheus registry when collecting metrics.
func (c *minioCollector) Collect(ch chan<- prometheus.Metric) {
	// Expose MinIO's version information
	minioVersionInfo.WithLabelValues(Version, CommitID).Set(1.0)

	}
	for range expFailure {
		globalTierMetrics.logFailure(tier)
	}
	metrics := globalTierMetrics.Report()
	var succ, fail float64
	for _, metric := range metrics {
		switch metric.Description.Name {
		case tierRequestsSuccess:
			succ += metric.Value
		case tierRequestsFailure:
			fail += metric.Value
		}
	}
	if int(succ) != expSuccess {

	}

	// Accumulate regular-cased API label metrics for 'PutObject' for deeper verification
	metrics := getHistogramMetrics(ttfbHist, getBucketTTFBDistributionMD(), false, false)
	capitalPutObjects := make([]MetricV2, 0, len(histBuckets)+1)
	for _, metric := range metrics {
		if value := metric.VariableLabels["api"]; value == "PutObject" {
			capitalPutObjects = append(capitalPutObjects, metric)
		}
	}

- MinIO exports Prometheus compatible data by default which is node centric as an authorized endpoint at `/minio/v2/metrics/node`.
- MinIO exports Prometheus compatible data by default which is resource centric as an authorized endpoint at `/minio/v2/metrics/resource`.