// loadMemoryMetrics - `MetricsLoaderFn` for node memory metrics.
func loadMemoryMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	memMetrics, err := c.memoryMetrics.Get()
	if err != nil {
		metricsLogIf(ctx, err)
		return err
	}

	m.Set(memTotal, float64(memMetrics.Total))
	m.Set(memUsed, float64(memMetrics.Used))
	usedPerc := float64(memMetrics.Used) * 100 / float64(memMetrics.Total)
	m.Set(memUsedPerc, usedPerc)

import (
	"context"
	"sync"
	"time"

	"github.com/minio/madmin-go/v3"
	"github.com/minio/minio/internal/cachevalue"
)

// metricsCache - cache for metrics.
//
// When serving metrics, this cache is passed to the MetricsLoaderFn.
//
// This cache is used for metrics that would result in network/storage calls.
type metricsCache struct {
	dataUsageInfo       *cachevalue.Cache[DataUsageInfo]

// loadCPUMetrics - `MetricsLoaderFn` for system CPU metrics.
func loadCPUMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	cpuMetrics, _ := c.cpuMetrics.Get()

	if cpuMetrics.LoadStat != nil {
		m.Set(sysCPULoad, cpuMetrics.LoadStat.Load1)
		perc := cpuMetrics.LoadStat.Load1 * 100 / float64(cpuMetrics.CPUCount)
		m.Set(sysCPULoadPerc, math.Round(perc*100)/100)
	}

	ts := cpuMetrics.TimesStat

	EndpointsDesired = metrics.NewGaugeVec(
		&metrics.GaugeOpts{
			Subsystem:      EndpointSliceMirroringSubsystem,
			Name:           "endpoints_desired",
			Help:           "Number of endpoints desired",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{},
	)
	// NumEndpointSlices tracks the number of EndpointSlices in a cluster.
	NumEndpointSlices = metrics.NewGaugeVec(
		&metrics.GaugeOpts{

*/

package serviceaccount

import (
	"sync"

	"k8s.io/component-base/metrics"
	"k8s.io/component-base/metrics/legacyregistry"
)

const kubeServiceAccountSubsystem = "serviceaccount"

var (
	// LegacyTokensTotal is the number of legacy tokens used against apiserver.
	legacyTokensTotal = metrics.NewCounter(
		&metrics.CounterOpts{
			Subsystem:      kubeServiceAccountSubsystem,

limitations under the License.
*/

package metrics

import (
	"sync"
	"time"

	"k8s.io/component-base/metrics"
	"k8s.io/component-base/metrics/legacyregistry"
)

const (
	kubeletSubsystem = "kubelet"
)

var (
	// HTTPRequests tracks the number of the http requests received since the server started.
	HTTPRequests = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Subsystem:      kubeletSubsystem,

	conversionWebhookRequest := metrics.NewCounterVec(
		&metrics.CounterOpts{
			Name:           "conversion_webhook_request_total",
			Namespace:      namespace,
			Help:           "Counter for conversion webhook requests with success/failure and failure error type",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{"result", "failure_type"})

	conversionWebhookLatency := metrics.NewHistogramVec(
		&metrics.HistogramOpts{

			Help:           "Time (in seconds) of inter arrival of transformation requests.",
			StabilityLevel: metrics.ALPHA,
			Buckets:        metrics.ExponentialBuckets(60, 2, 10),
		},
		[]string{"transformation_type"},
	)

	// These metrics are made public to be used by unit tests.
	KMSOperationsLatencyMetric = metrics.NewHistogramVec(
		&metrics.HistogramOpts{
			Namespace:      namespace,
			Subsystem:      subsystem,

limitations under the License.
*/

package metrics

import (
	"sync"

	"k8s.io/component-base/metrics"
	"k8s.io/component-base/metrics/legacyregistry"
)

const (
	podGCController = "pod_gc_collector"
)

var (
	DeletingPodsTotal = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Subsystem:      podGCController,
			Name:           "force_delete_pods_total",

	JobDeletionDurationSeconds = metrics.NewHistogram(
		&metrics.HistogramOpts{
			Subsystem:      TTLAfterFinishedSubsystem,
			Name:           "job_deletion_duration_seconds",
			Help:           "The time it took to delete the job since it became eligible for deletion",
			StabilityLevel: metrics.ALPHA,
			// Start with 100ms with the last bucket being [~27m, Inf).
			Buckets: metrics.ExponentialBuckets(0.1, 2, 14),
		},
	)
)