func (r *monitor) ObserveMetricComputationResult(action ActionLabel, err ErrorLabel, duration time.Duration, metricType v2.MetricSourceType) {
	metricComputationTotal.WithLabelValues(string(action), string(err), string(metricType)).Inc()
	metricComputationDuration.WithLabelValues(string(action), string(err), string(metricType)).Observe(duration.Seconds())

	utilization := in.TargetAverageUtilization
	averageValue := in.TargetAverageValue

	var metricType autoscaling.MetricTargetType
	if utilization == nil {
		metricType = autoscaling.AverageValueMetricType
	} else {
		metricType = autoscaling.UtilizationMetricType
	}
	out.Target = autoscaling.MetricTarget{
		Type:               metricType,
		AverageValue:       averageValue,
		AverageUtilization: utilization,
	}
	return nil
}

	value := in.TargetValue
	averageValue := in.TargetAverageValue
	var metricType autoscaling.MetricTargetType
	if value == nil {
		metricType = autoscaling.AverageValueMetricType
	} else {
		metricType = autoscaling.ValueMetricType
	}
	out.Target = autoscaling.MetricTarget{
		Type:         metricType,
		Value:        value,
		AverageValue: averageValue,
	}

	expectedValue       int64
}

type metricType int

const (
	objectMetric metricType = iota
	objectPerPodMetric
	externalMetric
	externalPerPodMetric
	podMetric
)

type metricInfo struct {
	name         string
	levels       []int64
	singleObject *autoscalingv2.CrossVersionObjectReference
	selector     *metav1.LabelSelector
	metricType   metricType

	targetUsage       int64
	perPodTargetUsage int64

}

// MetricType - represents the type of a metric.
type MetricType int

const (
	// CounterMT - represents a counter metric.
	CounterMT MetricType = iota
	// GaugeMT - represents a gauge metric.
	GaugeMT
	// HistogramMT - represents a histogram metric.
	HistogramMT
	// rangeL - represents a range label.
	rangeL = "range"
)

func (mt MetricType) String() string {
	switch mt {

		klog.V(5).ErrorS(err, "Descriptor not present in pre-populated list of descriptors", "name", m.Name)
		return nil, err
	}

	typ := criTypeToProm[m.MetricType]

	pm, err := metrics.NewConstMetric(desc, typ, float64(m.GetValue().Value), m.LabelValues...)
	if err != nil {
		klog.ErrorS(err, "Error getting CRI prometheus metric", "descriptor", desc.String())
		return nil, err

	"github.com/shirou/gopsutil/v3/load"
)

type collectMetricsOpts struct {
	hosts map[string]struct{}
	disks map[string]struct{}
	jobID string
	depID string
}

func collectLocalMetrics(types madmin.MetricType, opts collectMetricsOpts) (m madmin.RealtimeMetrics) {
	if types == madmin.MetricsNone {
		return
	}

	byHostName := globalMinioAddr
	if len(opts.hosts) > 0 {

		loadDriveMetrics)
}

func newCPUMetricsCache() *cachevalue.Cache[madmin.CPUMetrics] {
	loadCPUMetrics := func(ctx context.Context) (v madmin.CPUMetrics, err error) {
		var types madmin.MetricType = madmin.MetricsCPU

		m := collectLocalMetrics(types, collectMetricsOpts{
			hosts: map[string]struct{}{
				globalLocalNodeName: {},
			},
		})

		for _, hm := range m.ByHost {

	}

	for metricType, l := range tc.expectedReportedMetricComputationActionLabels {
		_, ok := m.metricComputationActionLabels[metricType]
		if !ok {
			t.Fatalf("the metric computation action should be recorded with metricType %s, but actually nothing was recorded", metricType)
		}

	drivePercUtilMD = NewGaugeMD(drivePercUtil,
		"Percentage of time the disk was busy",
		allDriveLabels...)
)

func getCurrentDriveIOStats() map[string]madmin.DiskIOStats {
	var types madmin.MetricType = madmin.MetricsDisk
	driveRealtimeMetrics := collectLocalMetrics(types, collectMetricsOpts{
		hosts: map[string]struct{}{
			globalLocalNodeName: {},
		},
	})

	stats := map[string]madmin.DiskIOStats{}