Add constants

Signed-off-by: Sean Holcomb <seanholcomb@gmail.com>

core/pkg/source/datasource.go

@@ -8,6 +8,215 @@ import (
 	"github.com/opencost/opencost/core/pkg/diagnostics"
 )
 
+// Query name constants for use with MockMetricsQuerier.SetOverride.
+const (
+	// Local Cluster Disks
+	QueryLocalStorageActiveMinutes = "QueryLocalStorageActiveMinutes"
+	QueryLocalStorageUsedAvg       = "QueryLocalStorageUsedAvg"
+	QueryLocalStorageUsedMax       = "QueryLocalStorageUsedMax"
+	QueryLocalStorageBytes         = "QueryLocalStorageBytes"
+	QueryKMLocalStorageUsedAvg     = "QueryKMLocalStorageUsedAvg"
+	QueryKMLocalStorageUsedMax     = "QueryKMLocalStorageUsedMax"
+	QueryKMLocalStorageBytes       = "QueryKMLocalStorageBytes"
+
+	// Nodes
+	QueryNodeInfo                 = "QueryNodeInfo"
+	QueryNodeUptime               = "QueryNodeUptime"
+	QueryNodeActiveMinutes        = "QueryNodeActiveMinutes"
+	QueryNodeCPUCoresCapacity     = "QueryNodeCPUCoresCapacity"
+	QueryNodeCPUCoresAllocatable  = "QueryNodeCPUCoresAllocatable"
+	QueryNodeRAMBytesCapacity     = "QueryNodeRAMBytesCapacity"
+	QueryNodeRAMBytesAllocatable  = "QueryNodeRAMBytesAllocatable"
+	QueryNodeGPUCount             = "QueryNodeGPUCount"
+	QueryNodeCPUModeTotal         = "QueryNodeCPUModeTotal"
+	QueryNodeIsSpot               = "QueryNodeIsSpot"
+	QueryNodeRAMSystemPercent     = "QueryNodeRAMSystemPercent"
+	QueryNodeRAMUserPercent       = "QueryNodeRAMUserPercent"
+	QueryNodeResourceCapacities   = "QueryNodeResourceCapacities"
+	QueryNodeResourcesAllocatable = "QueryNodeResourcesAllocatable"
+
+	// Load Balancers
+	QueryLBActiveMinutes = "QueryLBActiveMinutes"
+	QueryLBPricePerHr    = "QueryLBPricePerHr"
+
+	// Cluster Management
+	QueryClusterInfo                   = "QueryClusterInfo"
+	QueryClusterUptime                 = "QueryClusterUptime"
+	QueryClusterManagementDuration     = "QueryClusterManagementDuration"
+	QueryClusterManagementPricePerHr   = "QueryClusterManagementPricePerHr"
+
+	// Pods
+	QueryPods                   = "QueryPods"
+	QueryPodsUID                = "QueryPodsUID"
+	QueryPodInfo                = "QueryPodInfo"
+	QueryPodUptime              = "QueryPodUptime"
+	QueryPodOwners              = "QueryPodOwners"
+	QueryPodPVCVolumes          = "QueryPodPVCVolumes"
+	QueryPodNetworkEgressBytes  = "QueryPodNetworkEgressBytes"
+	QueryPodNetworkIngressBytes = "QueryPodNetworkIngressBytes"
+
+	// Container
+	QueryContainerUptime            = "QueryContainerUptime"
+	QueryContainerResourceRequests  = "QueryContainerResourceRequests"
+	QueryContainerResourceLimits    = "QueryContainerResourceLimits"
+
+	// RAM
+	QueryRAMBytesAllocated   = "QueryRAMBytesAllocated"
+	QueryRAMRequests         = "QueryRAMRequests"
+	QueryRAMLimits           = "QueryRAMLimits"
+	QueryRAMUsageAvg         = "QueryRAMUsageAvg"
+	QueryRAMUsageMax         = "QueryRAMUsageMax"
+	QueryNodeRAMPricePerGiBHr = "QueryNodeRAMPricePerGiBHr"
+
+	// CPU
+	QueryCPUCoresAllocated = "QueryCPUCoresAllocated"
+	QueryCPURequests       = "QueryCPURequests"
+	QueryCPULimits         = "QueryCPULimits"
+	QueryCPUUsageAvg       = "QueryCPUUsageAvg"
+	QueryCPUUsageMax       = "QueryCPUUsageMax"
+	QueryNodeCPUPricePerHr = "QueryNodeCPUPricePerHr"
+
+	// GPU
+	QueryGPUsAllocated    = "QueryGPUsAllocated"
+	QueryGPUsRequested    = "QueryGPUsRequested"
+	QueryGPUsUsageAvg     = "QueryGPUsUsageAvg"
+	QueryGPUsUsageMax     = "QueryGPUsUsageMax"
+	QueryNodeGPUPricePerHr = "QueryNodeGPUPricePerHr"
+	QueryGPUInfo          = "QueryGPUInfo"
+	QueryIsGPUShared      = "QueryIsGPUShared"
+
+	// Device
+	QueryDCGMDeviceInfo        = "QueryDCGMDeviceInfo"
+	QueryDCGMDeviceUptime      = "QueryDCGMDeviceUptime"
+	QueryDCGMContainerUsageAvg = "QueryDCGMContainerUsageAvg"
+	QueryDCGMContainerUsageMax = "QueryDCGMContainerUsageMax"
+
+	// PVC
+	QueryPodPVCAllocation   = "QueryPodPVCAllocation"
+	QueryPVCBytesRequested  = "QueryPVCBytesRequested"
+	QueryPVCInfo            = "QueryPVCInfo"
+	QueryKMPVCInfo          = "QueryKMPVCInfo"
+	QueryPVCUptime          = "QueryPVCUptime"
+	QueryPVCBytesUsedAverage = "QueryPVCBytesUsedAverage"
+	QueryPVCBytesUsedMax    = "QueryPVCBytesUsedMax"
+
+	// PV
+	QueryPVBytes        = "QueryPVBytes"
+	QueryPVPricePerGiBHour = "QueryPVPricePerGiBHour"
+	QueryPVInfo         = "QueryPVInfo"
+	QueryPVActiveMinutes = "QueryPVActiveMinutes"
+	QueryPVUsedAverage  = "QueryPVUsedAverage"
+	QueryPVUsedMax      = "QueryPVUsedMax"
+	QueryKMPVInfo       = "QueryKMPVInfo"
+	QueryPVUptime       = "QueryPVUptime"
+
+	// Deployment
+	QueryDeploymentInfo        = "QueryDeploymentInfo"
+	QueryDeploymentUptime      = "QueryDeploymentUptime"
+	QueryDeploymentLabels      = "QueryDeploymentLabels"
+	QueryDeploymentAnnotations = "QueryDeploymentAnnotations"
+	QueryDeploymentMatchLabels = "QueryDeploymentMatchLabels"
+
+	// StatefulSet
+	QueryStatefulSetInfo        = "QueryStatefulSetInfo"
+	QueryStatefulSetUptime      = "QueryStatefulSetUptime"
+	QueryStatefulSetLabels      = "QueryStatefulSetLabels"
+	QueryStatefulSetAnnotations = "QueryStatefulSetAnnotations"
+	QueryStatefulSetMatchLabels = "QueryStatefulSetMatchLabels"
+
+	// DaemonSet
+	QueryDaemonSetInfo        = "QueryDaemonSetInfo"
+	QueryDaemonSetUptime      = "QueryDaemonSetUptime"
+	QueryDaemonSetLabels      = "QueryDaemonSetLabels"
+	QueryDaemonSetAnnotations = "QueryDaemonSetAnnotations"
+
+	// Job
+	QueryJobInfo        = "QueryJobInfo"
+	QueryJobUptime      = "QueryJobUptime"
+	QueryJobLabels      = "QueryJobLabels"
+	QueryJobAnnotations = "QueryJobAnnotations"
+
+	// CronJob
+	QueryCronJobInfo        = "QueryCronJobInfo"
+	QueryCronJobUptime      = "QueryCronJobUptime"
+	QueryCronJobLabels      = "QueryCronJobLabels"
+	QueryCronJobAnnotations = "QueryCronJobAnnotations"
+
+	// ReplicaSet
+	QueryReplicaSetInfo             = "QueryReplicaSetInfo"
+	QueryReplicaSetUptime           = "QueryReplicaSetUptime"
+	QueryReplicaSetLabels           = "QueryReplicaSetLabels"
+	QueryReplicaSetAnnotations      = "QueryReplicaSetAnnotations"
+	QueryReplicaSetOwners           = "QueryReplicaSetOwners"
+	QueryPodsWithReplicaSetOwner    = "QueryPodsWithReplicaSetOwner"
+	QueryReplicaSetsWithoutOwners   = "QueryReplicaSetsWithoutOwners"
+	QueryReplicaSetsWithRollout     = "QueryReplicaSetsWithRollout"
+
+	// Namespace
+	QueryNamespaceInfo        = "QueryNamespaceInfo"
+	QueryNamespaceUptime      = "QueryNamespaceUptime"
+	QueryNamespaceAnnotations = "QueryNamespaceAnnotations"
+	QueryNamespaceLabels      = "QueryNamespaceLabels"
+
+	// Service
+	QueryServiceInfo           = "QueryServiceInfo"
+	QueryServiceUptime         = "QueryServiceUptime"
+	QueryServiceSelectorLabels = "QueryServiceSelectorLabels"
+
+	// Network Egress
+	QueryNetZoneGiB              = "QueryNetZoneGiB"
+	QueryNetZonePricePerGiB      = "QueryNetZonePricePerGiB"
+	QueryNetRegionGiB            = "QueryNetRegionGiB"
+	QueryNetRegionPricePerGiB    = "QueryNetRegionPricePerGiB"
+	QueryNetInternetGiB          = "QueryNetInternetGiB"
+	QueryNetInternetPricePerGiB  = "QueryNetInternetPricePerGiB"
+	QueryNetInternetServiceGiB   = "QueryNetInternetServiceGiB"
+	QueryNetNatGatewayPricePerGiB = "QueryNetNatGatewayPricePerGiB"
+	QueryNetNatGatewayGiB        = "QueryNetNatGatewayGiB"
+	QueryNetTransferBytes        = "QueryNetTransferBytes"
+
+	// Network Ingress
+	QueryNetZoneIngressGiB              = "QueryNetZoneIngressGiB"
+	QueryNetRegionIngressGiB            = "QueryNetRegionIngressGiB"
+	QueryNetInternetIngressGiB          = "QueryNetInternetIngressGiB"
+	QueryNetInternetServiceIngressGiB   = "QueryNetInternetServiceIngressGiB"
+	QueryNetNatGatewayIngressPricePerGiB = "QueryNetNatGatewayIngressPricePerGiB"
+	QueryNetNatGatewayIngressGiB        = "QueryNetNatGatewayIngressGiB"
+	QueryNetReceiveBytes                = "QueryNetReceiveBytes"
+
+	// Labels
+	QueryNodeLabels = "QueryNodeLabels"
+	QueryPodLabels  = "QueryPodLabels"
+
+	// Pod ownership
+	QueryPodAnnotations         = "QueryPodAnnotations"
+	QueryPodsWithDaemonSetOwner = "QueryPodsWithDaemonSetOwner"
+	QueryPodsWithJobOwner       = "QueryPodsWithJobOwner"
+
+	// ResourceQuotas
+	QueryResourceQuotaInfo                          = "QueryResourceQuotaInfo"
+	QueryResourceQuotaUptime                        = "QueryResourceQuotaUptime"
+	QueryResourceQuotaSpecCPURequestAverage         = "QueryResourceQuotaSpecCPURequestAverage"
+	QueryResourceQuotaSpecCPURequestMax             = "QueryResourceQuotaSpecCPURequestMax"
+	QueryResourceQuotaSpecRAMRequestAverage         = "QueryResourceQuotaSpecRAMRequestAverage"
+	QueryResourceQuotaSpecRAMRequestMax             = "QueryResourceQuotaSpecRAMRequestMax"
+	QueryResourceQuotaSpecCPULimitAverage           = "QueryResourceQuotaSpecCPULimitAverage"
+	QueryResourceQuotaSpecCPULimitMax               = "QueryResourceQuotaSpecCPULimitMax"
+	QueryResourceQuotaSpecRAMLimitAverage           = "QueryResourceQuotaSpecRAMLimitAverage"
+	QueryResourceQuotaSpecRAMLimitMax               = "QueryResourceQuotaSpecRAMLimitMax"
+	QueryResourceQuotaStatusUsedCPURequestAverage   = "QueryResourceQuotaStatusUsedCPURequestAverage"
+	QueryResourceQuotaStatusUsedCPURequestMax       = "QueryResourceQuotaStatusUsedCPURequestMax"
+	QueryResourceQuotaStatusUsedRAMRequestAverage   = "QueryResourceQuotaStatusUsedRAMRequestAverage"
+	QueryResourceQuotaStatusUsedRAMRequestMax       = "QueryResourceQuotaStatusUsedRAMRequestMax"
+	QueryResourceQuotaStatusUsedCPULimitAverage     = "QueryResourceQuotaStatusUsedCPULimitAverage"
+	QueryResourceQuotaStatusUsedCPULimitMax         = "QueryResourceQuotaStatusUsedCPULimitMax"
+	QueryResourceQuotaStatusUsedRAMLimitAverage     = "QueryResourceQuotaStatusUsedRAMLimitAverage"
+	QueryResourceQuotaStatusUsedRAMLimitMax         = "QueryResourceQuotaStatusUsedRAMLimitMax"
+
+	// Data Coverage
+	QueryDataCoverage = "QueryDataCoverage"
+)
+
 type MetricsQuerier interface {
 	// Cluster Disks
 

core/pkg/source/mock.go

@@ -0,0 +1,1078 @@
+package source
+
+import (
+	"time"
+
+	"github.com/julienschmidt/httprouter"
+	"github.com/opencost/opencost/core/pkg/clusters"
+	"github.com/opencost/opencost/core/pkg/diagnostics"
+)
+
+//--------------------------------------------------------------------------
+//  Mock MetricsQuerier (per-method override map, NoOp fallback)
+//--------------------------------------------------------------------------
+
+var _ MetricsQuerier = (*MockMetricsQuerier)(nil)
+
+// MockMetricsQuerier is a test double for MetricsQuerier. Set a field to a
+// non-nil *Future[T] to override what a specific method returns; unset methods
+// fall back to NoOpMetricsQuerier (empty results, no error).
+type MockMetricsQuerier struct {
+	noop      *NoOpMetricsQuerier
+	overrides map[string]any
+}
+
+func NewMockMetricsQuerier() *MockMetricsQuerier {
+	return &MockMetricsQuerier{
+		noop:      NewNoOpMetricsQuerier(),
+		overrides: make(map[string]any),
+	}
+}
+
+// SetOverride registers a *Future[T] to be returned when method is called.
+// Pass nil to clear an override.
+func (m *MockMetricsQuerier) SetOverride(method string, result any) {
+	if result == nil {
+		delete(m.overrides, method)
+		return
+	}
+	m.overrides[method] = result
+}
+
+// resolve returns the override for method if one is set and type-asserts correctly,
+// otherwise calls fallback.
+func resolve[T any](overrides map[string]any, method string, fallback func() *Future[T]) *Future[T] {
+	if v, ok := overrides[method]; ok {
+		if f, ok := v.(*Future[T]); ok {
+			return f
+		}
+	}
+	return fallback()
+}
+
+// Local Cluster Disks
+
+func (m *MockMetricsQuerier) QueryLocalStorageActiveMinutes(start, end time.Time) *Future[LocalStorageActiveMinutesResult] {
+	return resolve(m.overrides, QueryLocalStorageActiveMinutes, func() *Future[LocalStorageActiveMinutesResult] {
+		return m.noop.QueryLocalStorageActiveMinutes(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryLocalStorageUsedAvg(start, end time.Time) *Future[LocalStorageUsedAvgResult] {
+	return resolve(m.overrides, QueryLocalStorageUsedAvg, func() *Future[LocalStorageUsedAvgResult] {
+		return m.noop.QueryLocalStorageUsedAvg(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryLocalStorageUsedMax(start, end time.Time) *Future[LocalStorageUsedMaxResult] {
+	return resolve(m.overrides, QueryLocalStorageUsedMax, func() *Future[LocalStorageUsedMaxResult] {
+		return m.noop.QueryLocalStorageUsedMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryLocalStorageBytes(start, end time.Time) *Future[LocalStorageBytesResult] {
+	return resolve(m.overrides, QueryLocalStorageBytes, func() *Future[LocalStorageBytesResult] {
+		return m.noop.QueryLocalStorageBytes(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryKMLocalStorageUsedAvg(start, end time.Time) *Future[NodeUIDValueResult] {
+	return resolve(m.overrides, QueryKMLocalStorageUsedAvg, func() *Future[NodeUIDValueResult] {
+		return m.noop.QueryKMLocalStorageUsedAvg(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryKMLocalStorageUsedMax(start, end time.Time) *Future[NodeUIDValueResult] {
+	return resolve(m.overrides, QueryKMLocalStorageUsedMax, func() *Future[NodeUIDValueResult] {
+		return m.noop.QueryKMLocalStorageUsedMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryKMLocalStorageBytes(start, end time.Time) *Future[UIDValueResult] {
+	return resolve(m.overrides, QueryKMLocalStorageBytes, func() *Future[UIDValueResult] {
+		return m.noop.QueryKMLocalStorageBytes(start, end)
+	})
+}
+
+// Nodes
+
+func (m *MockMetricsQuerier) QueryNodeInfo(start, end time.Time) *Future[NodeInfoResult] {
+	return resolve(m.overrides, QueryNodeInfo, func() *Future[NodeInfoResult] {
+		return m.noop.QueryNodeInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryNodeUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryNodeUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeActiveMinutes(start, end time.Time) *Future[NodeActiveMinutesResult] {
+	return resolve(m.overrides, QueryNodeActiveMinutes, func() *Future[NodeActiveMinutesResult] {
+		return m.noop.QueryNodeActiveMinutes(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeCPUCoresCapacity(start, end time.Time) *Future[NodeCPUCoresCapacityResult] {
+	return resolve(m.overrides, QueryNodeCPUCoresCapacity, func() *Future[NodeCPUCoresCapacityResult] {
+		return m.noop.QueryNodeCPUCoresCapacity(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeCPUCoresAllocatable(start, end time.Time) *Future[NodeCPUCoresAllocatableResult] {
+	return resolve(m.overrides, QueryNodeCPUCoresAllocatable, func() *Future[NodeCPUCoresAllocatableResult] {
+		return m.noop.QueryNodeCPUCoresAllocatable(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeRAMBytesCapacity(start, end time.Time) *Future[NodeRAMBytesCapacityResult] {
+	return resolve(m.overrides, QueryNodeRAMBytesCapacity, func() *Future[NodeRAMBytesCapacityResult] {
+		return m.noop.QueryNodeRAMBytesCapacity(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeRAMBytesAllocatable(start, end time.Time) *Future[NodeRAMBytesAllocatableResult] {
+	return resolve(m.overrides, QueryNodeRAMBytesAllocatable, func() *Future[NodeRAMBytesAllocatableResult] {
+		return m.noop.QueryNodeRAMBytesAllocatable(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeGPUCount(start, end time.Time) *Future[NodeGPUCountResult] {
+	return resolve(m.overrides, QueryNodeGPUCount, func() *Future[NodeGPUCountResult] {
+		return m.noop.QueryNodeGPUCount(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeCPUModeTotal(start, end time.Time) *Future[NodeCPUModeTotalResult] {
+	return resolve(m.overrides, QueryNodeCPUModeTotal, func() *Future[NodeCPUModeTotalResult] {
+		return m.noop.QueryNodeCPUModeTotal(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeIsSpot(start, end time.Time) *Future[NodeIsSpotResult] {
+	return resolve(m.overrides, QueryNodeIsSpot, func() *Future[NodeIsSpotResult] {
+		return m.noop.QueryNodeIsSpot(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeRAMSystemPercent(start, end time.Time) *Future[NodeRAMSystemPercentResult] {
+	return resolve(m.overrides, QueryNodeRAMSystemPercent, func() *Future[NodeRAMSystemPercentResult] {
+		return m.noop.QueryNodeRAMSystemPercent(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeRAMUserPercent(start, end time.Time) *Future[NodeRAMUserPercentResult] {
+	return resolve(m.overrides, QueryNodeRAMUserPercent, func() *Future[NodeRAMUserPercentResult] {
+		return m.noop.QueryNodeRAMUserPercent(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeResourceCapacities(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryNodeResourceCapacities, func() *Future[ResourceResult] {
+		return m.noop.QueryNodeResourceCapacities(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeResourcesAllocatable(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryNodeResourcesAllocatable, func() *Future[ResourceResult] {
+		return m.noop.QueryNodeResourcesAllocatable(start, end)
+	})
+}
+
+// Load Balancers
+
+func (m *MockMetricsQuerier) QueryLBActiveMinutes(start, end time.Time) *Future[LBActiveMinutesResult] {
+	return resolve(m.overrides, QueryLBActiveMinutes, func() *Future[LBActiveMinutesResult] {
+		return m.noop.QueryLBActiveMinutes(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryLBPricePerHr(start, end time.Time) *Future[LBPricePerHrResult] {
+	return resolve(m.overrides, QueryLBPricePerHr, func() *Future[LBPricePerHrResult] {
+		return m.noop.QueryLBPricePerHr(start, end)
+	})
+}
+
+// Cluster Management
+
+func (m *MockMetricsQuerier) QueryClusterInfo(start, end time.Time) *Future[ClusterInfoResult] {
+	return resolve(m.overrides, QueryClusterInfo, func() *Future[ClusterInfoResult] {
+		return m.noop.QueryClusterInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryClusterUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryClusterUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryClusterUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryClusterManagementDuration(start, end time.Time) *Future[ClusterManagementDurationResult] {
+	return resolve(m.overrides, QueryClusterManagementDuration, func() *Future[ClusterManagementDurationResult] {
+		return m.noop.QueryClusterManagementDuration(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryClusterManagementPricePerHr(start, end time.Time) *Future[ClusterManagementPricePerHrResult] {
+	return resolve(m.overrides, QueryClusterManagementPricePerHr, func() *Future[ClusterManagementPricePerHrResult] {
+		return m.noop.QueryClusterManagementPricePerHr(start, end)
+	})
+}
+
+// Pods
+
+func (m *MockMetricsQuerier) QueryPods(start, end time.Time) *Future[PodsResult] {
+	return resolve(m.overrides, QueryPods, func() *Future[PodsResult] {
+		return m.noop.QueryPods(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodsUID(start, end time.Time) *Future[PodsResult] {
+	return resolve(m.overrides, QueryPodsUID, func() *Future[PodsResult] {
+		return m.noop.QueryPodsUID(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodInfo(start, end time.Time) *Future[PodInfoResult] {
+	return resolve(m.overrides, QueryPodInfo, func() *Future[PodInfoResult] {
+		return m.noop.QueryPodInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryPodUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryPodUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodOwners(start, end time.Time) *Future[OwnerResult] {
+	return resolve(m.overrides, QueryPodOwners, func() *Future[OwnerResult] {
+		return m.noop.QueryPodOwners(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodPVCVolumes(start, end time.Time) *Future[PodPVCVolumeResult] {
+	return resolve(m.overrides, QueryPodPVCVolumes, func() *Future[PodPVCVolumeResult] {
+		return m.noop.QueryPodPVCVolumes(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodNetworkEgressBytes(start, end time.Time) *Future[PodNetworkBytesResult] {
+	return resolve(m.overrides, QueryPodNetworkEgressBytes, func() *Future[PodNetworkBytesResult] {
+		return m.noop.QueryPodNetworkEgressBytes(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodNetworkIngressBytes(start, end time.Time) *Future[PodNetworkBytesResult] {
+	return resolve(m.overrides, QueryPodNetworkIngressBytes, func() *Future[PodNetworkBytesResult] {
+		return m.noop.QueryPodNetworkIngressBytes(start, end)
+	})
+}
+
+// Container
+
+func (m *MockMetricsQuerier) QueryContainerUptime(start, end time.Time) *Future[ContainerUptimeResult] {
+	return resolve(m.overrides, QueryContainerUptime, func() *Future[ContainerUptimeResult] {
+		return m.noop.QueryContainerUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryContainerResourceRequests(start, end time.Time) *Future[ContainerResourceResult] {
+	return resolve(m.overrides, QueryContainerResourceRequests, func() *Future[ContainerResourceResult] {
+		return m.noop.QueryContainerResourceRequests(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryContainerResourceLimits(start, end time.Time) *Future[ContainerResourceResult] {
+	return resolve(m.overrides, QueryContainerResourceLimits, func() *Future[ContainerResourceResult] {
+		return m.noop.QueryContainerResourceLimits(start, end)
+	})
+}
+
+// RAM
+
+func (m *MockMetricsQuerier) QueryRAMBytesAllocated(start, end time.Time) *Future[RAMBytesAllocatedResult] {
+	return resolve(m.overrides, QueryRAMBytesAllocated, func() *Future[RAMBytesAllocatedResult] {
+		return m.noop.QueryRAMBytesAllocated(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryRAMRequests(start, end time.Time) *Future[RAMRequestsResult] {
+	return resolve(m.overrides, QueryRAMRequests, func() *Future[RAMRequestsResult] {
+		return m.noop.QueryRAMRequests(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryRAMLimits(start, end time.Time) *Future[RAMLimitsResult] {
+	return resolve(m.overrides, QueryRAMLimits, func() *Future[RAMLimitsResult] {
+		return m.noop.QueryRAMLimits(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryRAMUsageAvg(start, end time.Time) *Future[RAMUsageAvgResult] {
+	return resolve(m.overrides, QueryRAMUsageAvg, func() *Future[RAMUsageAvgResult] {
+		return m.noop.QueryRAMUsageAvg(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryRAMUsageMax(start, end time.Time) *Future[RAMUsageMaxResult] {
+	return resolve(m.overrides, QueryRAMUsageMax, func() *Future[RAMUsageMaxResult] {
+		return m.noop.QueryRAMUsageMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeRAMPricePerGiBHr(start, end time.Time) *Future[NodeRAMPricePerGiBHrResult] {
+	return resolve(m.overrides, QueryNodeRAMPricePerGiBHr, func() *Future[NodeRAMPricePerGiBHrResult] {
+		return m.noop.QueryNodeRAMPricePerGiBHr(start, end)
+	})
+}
+
+// CPU
+
+func (m *MockMetricsQuerier) QueryCPUCoresAllocated(start, end time.Time) *Future[CPUCoresAllocatedResult] {
+	return resolve(m.overrides, QueryCPUCoresAllocated, func() *Future[CPUCoresAllocatedResult] {
+		return m.noop.QueryCPUCoresAllocated(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryCPURequests(start, end time.Time) *Future[CPURequestsResult] {
+	return resolve(m.overrides, QueryCPURequests, func() *Future[CPURequestsResult] {
+		return m.noop.QueryCPURequests(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryCPULimits(start, end time.Time) *Future[CPULimitsResult] {
+	return resolve(m.overrides, QueryCPULimits, func() *Future[CPULimitsResult] {
+		return m.noop.QueryCPULimits(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryCPUUsageAvg(start, end time.Time) *Future[CPUUsageAvgResult] {
+	return resolve(m.overrides, QueryCPUUsageAvg, func() *Future[CPUUsageAvgResult] {
+		return m.noop.QueryCPUUsageAvg(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryCPUUsageMax(start, end time.Time) *Future[CPUUsageMaxResult] {
+	return resolve(m.overrides, QueryCPUUsageMax, func() *Future[CPUUsageMaxResult] {
+		return m.noop.QueryCPUUsageMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeCPUPricePerHr(start, end time.Time) *Future[NodeCPUPricePerHrResult] {
+	return resolve(m.overrides, QueryNodeCPUPricePerHr, func() *Future[NodeCPUPricePerHrResult] {
+		return m.noop.QueryNodeCPUPricePerHr(start, end)
+	})
+}
+
+// GPU
+
+func (m *MockMetricsQuerier) QueryGPUsAllocated(start, end time.Time) *Future[GPUsAllocatedResult] {
+	return resolve(m.overrides, QueryGPUsAllocated, func() *Future[GPUsAllocatedResult] {
+		return m.noop.QueryGPUsAllocated(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryGPUsRequested(start, end time.Time) *Future[GPUsRequestedResult] {
+	return resolve(m.overrides, QueryGPUsRequested, func() *Future[GPUsRequestedResult] {
+		return m.noop.QueryGPUsRequested(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryGPUsUsageAvg(start, end time.Time) *Future[GPUsUsageAvgResult] {
+	return resolve(m.overrides, QueryGPUsUsageAvg, func() *Future[GPUsUsageAvgResult] {
+		return m.noop.QueryGPUsUsageAvg(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryGPUsUsageMax(start, end time.Time) *Future[GPUsUsageMaxResult] {
+	return resolve(m.overrides, QueryGPUsUsageMax, func() *Future[GPUsUsageMaxResult] {
+		return m.noop.QueryGPUsUsageMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNodeGPUPricePerHr(start, end time.Time) *Future[NodeGPUPricePerHrResult] {
+	return resolve(m.overrides, QueryNodeGPUPricePerHr, func() *Future[NodeGPUPricePerHrResult] {
+		return m.noop.QueryNodeGPUPricePerHr(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryGPUInfo(start, end time.Time) *Future[GPUInfoResult] {
+	return resolve(m.overrides, QueryGPUInfo, func() *Future[GPUInfoResult] {
+		return m.noop.QueryGPUInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryIsGPUShared(start, end time.Time) *Future[IsGPUSharedResult] {
+	return resolve(m.overrides, QueryIsGPUShared, func() *Future[IsGPUSharedResult] {
+		return m.noop.QueryIsGPUShared(start, end)
+	})
+}
+
+// Device
+
+func (m *MockMetricsQuerier) QueryDCGMDeviceInfo(start, end time.Time) *Future[DCGMDeviceInfoResult] {
+	return resolve(m.overrides, QueryDCGMDeviceInfo, func() *Future[DCGMDeviceInfoResult] {
+		return m.noop.QueryDCGMDeviceInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDCGMDeviceUptime(start, end time.Time) *Future[DCGMDeviceUptimeResult] {
+	return resolve(m.overrides, QueryDCGMDeviceUptime, func() *Future[DCGMDeviceUptimeResult] {
+		return m.noop.QueryDCGMDeviceUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDCGMContainerUsageAvg(start, end time.Time) *Future[DCGMDeviceContainerUsageResult] {
+	return resolve(m.overrides, QueryDCGMContainerUsageAvg, func() *Future[DCGMDeviceContainerUsageResult] {
+		return m.noop.QueryDCGMContainerUsageAvg(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDCGMContainerUsageMax(start, end time.Time) *Future[DCGMDeviceContainerUsageResult] {
+	return resolve(m.overrides, QueryDCGMContainerUsageMax, func() *Future[DCGMDeviceContainerUsageResult] {
+		return m.noop.QueryDCGMContainerUsageMax(start, end)
+	})
+}
+
+// PVC
+
+func (m *MockMetricsQuerier) QueryPodPVCAllocation(start, end time.Time) *Future[PodPVCAllocationResult] {
+	return resolve(m.overrides, QueryPodPVCAllocation, func() *Future[PodPVCAllocationResult] {
+		return m.noop.QueryPodPVCAllocation(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVCBytesRequested(start, end time.Time) *Future[PVCBytesRequestedResult] {
+	return resolve(m.overrides, QueryPVCBytesRequested, func() *Future[PVCBytesRequestedResult] {
+		return m.noop.QueryPVCBytesRequested(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVCInfo(start, end time.Time) *Future[PVCInfoResult] {
+	return resolve(m.overrides, QueryPVCInfo, func() *Future[PVCInfoResult] {
+		return m.noop.QueryPVCInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryKMPVCInfo(start, end time.Time) *Future[PVCInfoResult] {
+	return resolve(m.overrides, QueryKMPVCInfo, func() *Future[PVCInfoResult] {
+		return m.noop.QueryKMPVCInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVCUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryPVCUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryPVCUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVCBytesUsedAverage(start, end time.Time) *Future[PVCUIDValueResult] {
+	return resolve(m.overrides, QueryPVCBytesUsedAverage, func() *Future[PVCUIDValueResult] {
+		return m.noop.QueryPVCBytesUsedAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVCBytesUsedMax(start, end time.Time) *Future[PVCUIDValueResult] {
+	return resolve(m.overrides, QueryPVCBytesUsedMax, func() *Future[PVCUIDValueResult] {
+		return m.noop.QueryPVCBytesUsedMax(start, end)
+	})
+}
+
+// PV
+
+func (m *MockMetricsQuerier) QueryPVBytes(start, end time.Time) *Future[PVBytesResult] {
+	return resolve(m.overrides, QueryPVBytes, func() *Future[PVBytesResult] {
+		return m.noop.QueryPVBytes(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVPricePerGiBHour(start, end time.Time) *Future[PVPricePerGiBHourResult] {
+	return resolve(m.overrides, QueryPVPricePerGiBHour, func() *Future[PVPricePerGiBHourResult] {
+		return m.noop.QueryPVPricePerGiBHour(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVInfo(start, end time.Time) *Future[PVInfoResult] {
+	return resolve(m.overrides, QueryPVInfo, func() *Future[PVInfoResult] {
+		return m.noop.QueryPVInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVActiveMinutes(start, end time.Time) *Future[PVActiveMinutesResult] {
+	return resolve(m.overrides, QueryPVActiveMinutes, func() *Future[PVActiveMinutesResult] {
+		return m.noop.QueryPVActiveMinutes(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVUsedAverage(start, end time.Time) *Future[PVUsedAvgResult] {
+	return resolve(m.overrides, QueryPVUsedAverage, func() *Future[PVUsedAvgResult] {
+		return m.noop.QueryPVUsedAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVUsedMax(start, end time.Time) *Future[PVUsedMaxResult] {
+	return resolve(m.overrides, QueryPVUsedMax, func() *Future[PVUsedMaxResult] {
+		return m.noop.QueryPVUsedMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryKMPVInfo(start, end time.Time) *Future[PVInfoResult] {
+	return resolve(m.overrides, QueryKMPVInfo, func() *Future[PVInfoResult] {
+		return m.noop.QueryKMPVInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPVUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryPVUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryPVUptime(start, end)
+	})
+}
+
+// Deployment
+
+func (m *MockMetricsQuerier) QueryDeploymentInfo(start, end time.Time) *Future[DeploymentInfoResult] {
+	return resolve(m.overrides, QueryDeploymentInfo, func() *Future[DeploymentInfoResult] {
+		return m.noop.QueryDeploymentInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDeploymentUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryDeploymentUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryDeploymentUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDeploymentLabels(start, end time.Time) *Future[LabelsResult] {
+	return resolve(m.overrides, QueryDeploymentLabels, func() *Future[LabelsResult] {
+		return m.noop.QueryDeploymentLabels(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDeploymentAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return resolve(m.overrides, QueryDeploymentAnnotations, func() *Future[AnnotationsResult] {
+		return m.noop.QueryDeploymentAnnotations(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDeploymentMatchLabels(start, end time.Time) *Future[DeploymentLabelsResult] {
+	return resolve(m.overrides, QueryDeploymentMatchLabels, func() *Future[DeploymentLabelsResult] {
+		return m.noop.QueryDeploymentMatchLabels(start, end)
+	})
+}
+
+// StatefulSet
+
+func (m *MockMetricsQuerier) QueryStatefulSetInfo(start, end time.Time) *Future[StatefulSetInfoResult] {
+	return resolve(m.overrides, QueryStatefulSetInfo, func() *Future[StatefulSetInfoResult] {
+		return m.noop.QueryStatefulSetInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryStatefulSetUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryStatefulSetUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryStatefulSetUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryStatefulSetLabels(start, end time.Time) *Future[LabelsResult] {
+	return resolve(m.overrides, QueryStatefulSetLabels, func() *Future[LabelsResult] {
+		return m.noop.QueryStatefulSetLabels(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryStatefulSetAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return resolve(m.overrides, QueryStatefulSetAnnotations, func() *Future[AnnotationsResult] {
+		return m.noop.QueryStatefulSetAnnotations(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryStatefulSetMatchLabels(start, end time.Time) *Future[StatefulSetLabelsResult] {
+	return resolve(m.overrides, QueryStatefulSetMatchLabels, func() *Future[StatefulSetLabelsResult] {
+		return m.noop.QueryStatefulSetMatchLabels(start, end)
+	})
+}
+
+// DaemonSet
+
+func (m *MockMetricsQuerier) QueryDaemonSetInfo(start, end time.Time) *Future[DaemonSetInfoResult] {
+	return resolve(m.overrides, QueryDaemonSetInfo, func() *Future[DaemonSetInfoResult] {
+		return m.noop.QueryDaemonSetInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDaemonSetUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryDaemonSetUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryDaemonSetUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDaemonSetLabels(start, end time.Time) *Future[LabelsResult] {
+	return resolve(m.overrides, QueryDaemonSetLabels, func() *Future[LabelsResult] {
+		return m.noop.QueryDaemonSetLabels(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryDaemonSetAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return resolve(m.overrides, QueryDaemonSetAnnotations, func() *Future[AnnotationsResult] {
+		return m.noop.QueryDaemonSetAnnotations(start, end)
+	})
+}
+
+// Job
+
+func (m *MockMetricsQuerier) QueryJobInfo(start, end time.Time) *Future[JobInfoResult] {
+	return resolve(m.overrides, QueryJobInfo, func() *Future[JobInfoResult] {
+		return m.noop.QueryJobInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryJobUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryJobUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryJobUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryJobLabels(start, end time.Time) *Future[LabelsResult] {
+	return resolve(m.overrides, QueryJobLabels, func() *Future[LabelsResult] {
+		return m.noop.QueryJobLabels(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryJobAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return resolve(m.overrides, QueryJobAnnotations, func() *Future[AnnotationsResult] {
+		return m.noop.QueryJobAnnotations(start, end)
+	})
+}
+
+// CronJob
+
+func (m *MockMetricsQuerier) QueryCronJobInfo(start, end time.Time) *Future[CronJobInfoResult] {
+	return resolve(m.overrides, QueryCronJobInfo, func() *Future[CronJobInfoResult] {
+		return m.noop.QueryCronJobInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryCronJobUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryCronJobUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryCronJobUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryCronJobLabels(start, end time.Time) *Future[LabelsResult] {
+	return resolve(m.overrides, QueryCronJobLabels, func() *Future[LabelsResult] {
+		return m.noop.QueryCronJobLabels(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryCronJobAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return resolve(m.overrides, QueryCronJobAnnotations, func() *Future[AnnotationsResult] {
+		return m.noop.QueryCronJobAnnotations(start, end)
+	})
+}
+
+// ReplicaSet
+
+func (m *MockMetricsQuerier) QueryReplicaSetInfo(start, end time.Time) *Future[ReplicaSetInfoResult] {
+	return resolve(m.overrides, QueryReplicaSetInfo, func() *Future[ReplicaSetInfoResult] {
+		return m.noop.QueryReplicaSetInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryReplicaSetUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryReplicaSetUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryReplicaSetUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryReplicaSetLabels(start, end time.Time) *Future[LabelsResult] {
+	return resolve(m.overrides, QueryReplicaSetLabels, func() *Future[LabelsResult] {
+		return m.noop.QueryReplicaSetLabels(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryReplicaSetAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return resolve(m.overrides, QueryReplicaSetAnnotations, func() *Future[AnnotationsResult] {
+		return m.noop.QueryReplicaSetAnnotations(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryReplicaSetOwners(start, end time.Time) *Future[OwnerResult] {
+	return resolve(m.overrides, QueryReplicaSetOwners, func() *Future[OwnerResult] {
+		return m.noop.QueryReplicaSetOwners(start, end)
+	})
+}
+
+// Namespace
+
+func (m *MockMetricsQuerier) QueryNamespaceInfo(start, end time.Time) *Future[NamespaceInfoResult] {
+	return resolve(m.overrides, QueryNamespaceInfo, func() *Future[NamespaceInfoResult] {
+		return m.noop.QueryNamespaceInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNamespaceUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryNamespaceUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryNamespaceUptime(start, end)
+	})
+}
+
+// Service
+
+func (m *MockMetricsQuerier) QueryServiceInfo(start, end time.Time) *Future[ServiceInfoResult] {
+	return resolve(m.overrides, QueryServiceInfo, func() *Future[ServiceInfoResult] {
+		return m.noop.QueryServiceInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryServiceUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryServiceUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryServiceUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryServiceSelectorLabels(start, end time.Time) *Future[ServiceLabelsResult] {
+	return resolve(m.overrides, QueryServiceSelectorLabels, func() *Future[ServiceLabelsResult] {
+		return m.noop.QueryServiceSelectorLabels(start, end)
+	})
+}
+
+// Network Egress
+
+func (m *MockMetricsQuerier) QueryNetZoneGiB(start, end time.Time) *Future[NetZoneGiBResult] {
+	return resolve(m.overrides, QueryNetZoneGiB, func() *Future[NetZoneGiBResult] {
+		return m.noop.QueryNetZoneGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetZonePricePerGiB(start, end time.Time) *Future[NetZonePricePerGiBResult] {
+	return resolve(m.overrides, QueryNetZonePricePerGiB, func() *Future[NetZonePricePerGiBResult] {
+		return m.noop.QueryNetZonePricePerGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetRegionGiB(start, end time.Time) *Future[NetRegionGiBResult] {
+	return resolve(m.overrides, QueryNetRegionGiB, func() *Future[NetRegionGiBResult] {
+		return m.noop.QueryNetRegionGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetRegionPricePerGiB(start, end time.Time) *Future[NetRegionPricePerGiBResult] {
+	return resolve(m.overrides, QueryNetRegionPricePerGiB, func() *Future[NetRegionPricePerGiBResult] {
+		return m.noop.QueryNetRegionPricePerGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetInternetGiB(start, end time.Time) *Future[NetInternetGiBResult] {
+	return resolve(m.overrides, QueryNetInternetGiB, func() *Future[NetInternetGiBResult] {
+		return m.noop.QueryNetInternetGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetInternetPricePerGiB(start, end time.Time) *Future[NetInternetPricePerGiBResult] {
+	return resolve(m.overrides, QueryNetInternetPricePerGiB, func() *Future[NetInternetPricePerGiBResult] {
+		return m.noop.QueryNetInternetPricePerGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetInternetServiceGiB(start, end time.Time) *Future[NetInternetServiceGiBResult] {
+	return resolve(m.overrides, QueryNetInternetServiceGiB, func() *Future[NetInternetServiceGiBResult] {
+		return m.noop.QueryNetInternetServiceGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetNatGatewayPricePerGiB(start, end time.Time) *Future[NetNatGatewayPricePerGiBResult] {
+	return resolve(m.overrides, QueryNetNatGatewayPricePerGiB, func() *Future[NetNatGatewayPricePerGiBResult] {
+		return m.noop.QueryNetNatGatewayPricePerGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetNatGatewayGiB(start, end time.Time) *Future[NetNatGatewayGiBResult] {
+	return resolve(m.overrides, QueryNetNatGatewayGiB, func() *Future[NetNatGatewayGiBResult] {
+		return m.noop.QueryNetNatGatewayGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetTransferBytes(start, end time.Time) *Future[NetTransferBytesResult] {
+	return resolve(m.overrides, QueryNetTransferBytes, func() *Future[NetTransferBytesResult] {
+		return m.noop.QueryNetTransferBytes(start, end)
+	})
+}
+
+// Network Ingress
+
+func (m *MockMetricsQuerier) QueryNetZoneIngressGiB(start, end time.Time) *Future[NetZoneIngressGiBResult] {
+	return resolve(m.overrides, QueryNetZoneIngressGiB, func() *Future[NetZoneIngressGiBResult] {
+		return m.noop.QueryNetZoneIngressGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetRegionIngressGiB(start, end time.Time) *Future[NetRegionIngressGiBResult] {
+	return resolve(m.overrides, QueryNetRegionIngressGiB, func() *Future[NetRegionIngressGiBResult] {
+		return m.noop.QueryNetRegionIngressGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetInternetIngressGiB(start, end time.Time) *Future[NetInternetIngressGiBResult] {
+	return resolve(m.overrides, QueryNetInternetIngressGiB, func() *Future[NetInternetIngressGiBResult] {
+		return m.noop.QueryNetInternetIngressGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetInternetServiceIngressGiB(start, end time.Time) *Future[NetInternetServiceIngressGiBResult] {
+	return resolve(m.overrides, QueryNetInternetServiceIngressGiB, func() *Future[NetInternetServiceIngressGiBResult] {
+		return m.noop.QueryNetInternetServiceIngressGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetNatGatewayIngressPricePerGiB(start, end time.Time) *Future[NetNatGatewayPricePerGiBResult] {
+	return resolve(m.overrides, QueryNetNatGatewayIngressPricePerGiB, func() *Future[NetNatGatewayPricePerGiBResult] {
+		return m.noop.QueryNetNatGatewayIngressPricePerGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetNatGatewayIngressGiB(start, end time.Time) *Future[NetNatGatewayIngressGiBResult] {
+	return resolve(m.overrides, QueryNetNatGatewayIngressGiB, func() *Future[NetNatGatewayIngressGiBResult] {
+		return m.noop.QueryNetNatGatewayIngressGiB(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNetReceiveBytes(start, end time.Time) *Future[NetReceiveBytesResult] {
+	return resolve(m.overrides, QueryNetReceiveBytes, func() *Future[NetReceiveBytesResult] {
+		return m.noop.QueryNetReceiveBytes(start, end)
+	})
+}
+
+// Annotations
+
+func (m *MockMetricsQuerier) QueryNamespaceAnnotations(start, end time.Time) *Future[NamespaceAnnotationsResult] {
+	return resolve(m.overrides, QueryNamespaceAnnotations, func() *Future[NamespaceAnnotationsResult] {
+		return m.noop.QueryNamespaceAnnotations(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodAnnotations(start, end time.Time) *Future[PodAnnotationsResult] {
+	return resolve(m.overrides, QueryPodAnnotations, func() *Future[PodAnnotationsResult] {
+		return m.noop.QueryPodAnnotations(start, end)
+	})
+}
+
+// Labels
+
+func (m *MockMetricsQuerier) QueryNodeLabels(start, end time.Time) *Future[NodeLabelsResult] {
+	return resolve(m.overrides, QueryNodeLabels, func() *Future[NodeLabelsResult] {
+		return m.noop.QueryNodeLabels(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryNamespaceLabels(start, end time.Time) *Future[NamespaceLabelsResult] {
+	return resolve(m.overrides, QueryNamespaceLabels, func() *Future[NamespaceLabelsResult] {
+		return m.noop.QueryNamespaceLabels(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodLabels(start, end time.Time) *Future[PodLabelsResult] {
+	return resolve(m.overrides, QueryPodLabels, func() *Future[PodLabelsResult] {
+		return m.noop.QueryPodLabels(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodsWithDaemonSetOwner(start, end time.Time) *Future[PodsWithDaemonSetOwnerResult] {
+	return resolve(m.overrides, QueryPodsWithDaemonSetOwner, func() *Future[PodsWithDaemonSetOwnerResult] {
+		return m.noop.QueryPodsWithDaemonSetOwner(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryPodsWithJobOwner(start, end time.Time) *Future[PodsWithJobOwnerResult] {
+	return resolve(m.overrides, QueryPodsWithJobOwner, func() *Future[PodsWithJobOwnerResult] {
+		return m.noop.QueryPodsWithJobOwner(start, end)
+	})
+}
+
+// ReplicaSet -> Controller mapping
+
+func (m *MockMetricsQuerier) QueryPodsWithReplicaSetOwner(start, end time.Time) *Future[PodsWithReplicaSetOwnerResult] {
+	return resolve(m.overrides, QueryPodsWithReplicaSetOwner, func() *Future[PodsWithReplicaSetOwnerResult] {
+		return m.noop.QueryPodsWithReplicaSetOwner(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryReplicaSetsWithoutOwners(start, end time.Time) *Future[ReplicaSetsWithoutOwnersResult] {
+	return resolve(m.overrides, QueryReplicaSetsWithoutOwners, func() *Future[ReplicaSetsWithoutOwnersResult] {
+		return m.noop.QueryReplicaSetsWithoutOwners(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryReplicaSetsWithRollout(start, end time.Time) *Future[ReplicaSetsWithRolloutResult] {
+	return resolve(m.overrides, QueryReplicaSetsWithRollout, func() *Future[ReplicaSetsWithRolloutResult] {
+		return m.noop.QueryReplicaSetsWithRollout(start, end)
+	})
+}
+
+// ResourceQuotas
+
+func (m *MockMetricsQuerier) QueryResourceQuotaInfo(start, end time.Time) *Future[ResourceQuotaInfoResult] {
+	return resolve(m.overrides, QueryResourceQuotaInfo, func() *Future[ResourceQuotaInfoResult] {
+		return m.noop.QueryResourceQuotaInfo(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaUptime(start, end time.Time) *Future[UptimeResult] {
+	return resolve(m.overrides, QueryResourceQuotaUptime, func() *Future[UptimeResult] {
+		return m.noop.QueryResourceQuotaUptime(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaSpecCPURequestAverage(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaSpecCPURequestAverage, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaSpecCPURequestAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaSpecCPURequestMax(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaSpecCPURequestMax, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaSpecCPURequestMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaSpecRAMRequestAverage(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaSpecRAMRequestAverage, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaSpecRAMRequestAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaSpecRAMRequestMax(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaSpecRAMRequestMax, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaSpecRAMRequestMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaSpecCPULimitAverage(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaSpecCPULimitAverage, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaSpecCPULimitAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaSpecCPULimitMax(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaSpecCPULimitMax, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaSpecCPULimitMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaSpecRAMLimitAverage(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaSpecRAMLimitAverage, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaSpecRAMLimitAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaSpecRAMLimitMax(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaSpecRAMLimitMax, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaSpecRAMLimitMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaStatusUsedCPURequestAverage(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaStatusUsedCPURequestAverage, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaStatusUsedCPURequestAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaStatusUsedCPURequestMax(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaStatusUsedCPURequestMax, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaStatusUsedCPURequestMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaStatusUsedRAMRequestAverage(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaStatusUsedRAMRequestAverage, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaStatusUsedRAMRequestAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaStatusUsedRAMRequestMax(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaStatusUsedRAMRequestMax, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaStatusUsedRAMRequestMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaStatusUsedCPULimitAverage(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaStatusUsedCPULimitAverage, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaStatusUsedCPULimitAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaStatusUsedCPULimitMax(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaStatusUsedCPULimitMax, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaStatusUsedCPULimitMax(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaStatusUsedRAMLimitAverage(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaStatusUsedRAMLimitAverage, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaStatusUsedRAMLimitAverage(start, end)
+	})
+}
+
+func (m *MockMetricsQuerier) QueryResourceQuotaStatusUsedRAMLimitMax(start, end time.Time) *Future[ResourceResult] {
+	return resolve(m.overrides, QueryResourceQuotaStatusUsedRAMLimitMax, func() *Future[ResourceResult] {
+		return m.noop.QueryResourceQuotaStatusUsedRAMLimitMax(start, end)
+	})
+}
+
+// Data Coverage Query
+
+func (m *MockMetricsQuerier) QueryDataCoverage(limitDays int) (time.Time, time.Time, error) {
+	if v, ok := m.overrides[QueryDataCoverage]; ok {
+		if f, ok := v.(func(int) (time.Time, time.Time, error)); ok {
+			return f(limitDays)
+		}
+	}
+	return m.noop.QueryDataCoverage(limitDays)
+}
+
+//--------------------------------------------------------------------------
+//  Mock OpenCostDataSource
+//--------------------------------------------------------------------------
+
+var _ OpenCostDataSource = (*MockOpenCostDataSource)(nil)
+
+// MockOpenCostDataSource is a minimal OpenCostDataSource for tests. Set fields
+// directly to configure what the data source returns.
+type MockOpenCostDataSource struct {
+	Querier            *MockMetricsQuerier
+	ClusterMapValue    clusters.ClusterMap
+	ClusterInfoValue   clusters.ClusterInfoProvider
+	BatchDurationValue time.Duration
+	ResolutionValue    time.Duration
+}
+
+func NewMockOpenCostDataSource() *MockOpenCostDataSource {
+	return &MockOpenCostDataSource{
+		Querier: NewMockMetricsQuerier(),
+	}
+}
+
+func (m *MockOpenCostDataSource) RegisterEndPoints(_ *httprouter.Router) {}
+
+func (m *MockOpenCostDataSource) RegisterDiagnostics(_ diagnostics.DiagnosticService) {}
+
+func (m *MockOpenCostDataSource) Metrics() MetricsQuerier {
+	return m.Querier
+}
+
+func (m *MockOpenCostDataSource) ClusterMap() clusters.ClusterMap {
+	return m.ClusterMapValue
+}
+
+func (m *MockOpenCostDataSource) ClusterInfo() clusters.ClusterInfoProvider {
+	return m.ClusterInfoValue
+}
+
+func (m *MockOpenCostDataSource) BatchDuration() time.Duration {
+	return m.BatchDurationValue
+}
+
+func (m *MockOpenCostDataSource) Resolution() time.Duration {
+	return m.ResolutionValue
+}

core/pkg/source/record.go

@@ -29,823 +29,823 @@ func (m *RecordMetricsQuerier) recordCall(method string) {
 // Local Cluster Disks
 
 func (m *RecordMetricsQuerier) QueryLocalStorageActiveMinutes(start, end time.Time) *Future[LocalStorageActiveMinutesResult] {
-	m.recordCall("QueryLocalStorageActiveMinutes")
+	m.recordCall(QueryLocalStorageActiveMinutes)
 	return m.Querier.QueryLocalStorageActiveMinutes(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryLocalStorageUsedAvg(start, end time.Time) *Future[LocalStorageUsedAvgResult] {
-	m.recordCall("QueryLocalStorageUsedAvg")
+	m.recordCall(QueryLocalStorageUsedAvg)
 	return m.Querier.QueryLocalStorageUsedAvg(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryLocalStorageUsedMax(start, end time.Time) *Future[LocalStorageUsedMaxResult] {
-	m.recordCall("QueryLocalStorageUsedMax")
+	m.recordCall(QueryLocalStorageUsedMax)
 	return m.Querier.QueryLocalStorageUsedMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryLocalStorageBytes(start, end time.Time) *Future[LocalStorageBytesResult] {
-	m.recordCall("QueryLocalStorageBytes")
+	m.recordCall(QueryLocalStorageBytes)
 	return m.Querier.QueryLocalStorageBytes(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryKMLocalStorageUsedAvg(start, end time.Time) *Future[NodeUIDValueResult] {
-	m.recordCall("QueryKMLocalStorageUsedAvg")
+	m.recordCall(QueryKMLocalStorageUsedAvg)
 	return m.Querier.QueryKMLocalStorageUsedAvg(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryKMLocalStorageUsedMax(start, end time.Time) *Future[NodeUIDValueResult] {
-	m.recordCall("QueryKMLocalStorageUsedMax")
+	m.recordCall(QueryKMLocalStorageUsedMax)
 	return m.Querier.QueryKMLocalStorageUsedMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryKMLocalStorageBytes(start, end time.Time) *Future[UIDValueResult] {
-	m.recordCall("QueryKMLocalStorageBytes")
+	m.recordCall(QueryKMLocalStorageBytes)
 	return m.Querier.QueryKMLocalStorageBytes(start, end)
 }
 
 // Nodes
 
 func (m *RecordMetricsQuerier) QueryNodeInfo(start, end time.Time) *Future[NodeInfoResult] {
-	m.recordCall("QueryNodeInfo")
+	m.recordCall(QueryNodeInfo)
 	return m.Querier.QueryNodeInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryNodeUptime")
+	m.recordCall(QueryNodeUptime)
 	return m.Querier.QueryNodeUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeActiveMinutes(start, end time.Time) *Future[NodeActiveMinutesResult] {
-	m.recordCall("QueryNodeActiveMinutes")
+	m.recordCall(QueryNodeActiveMinutes)
 	return m.Querier.QueryNodeActiveMinutes(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeCPUCoresCapacity(start, end time.Time) *Future[NodeCPUCoresCapacityResult] {
-	m.recordCall("QueryNodeCPUCoresCapacity")
+	m.recordCall(QueryNodeCPUCoresCapacity)
 	return m.Querier.QueryNodeCPUCoresCapacity(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeCPUCoresAllocatable(start, end time.Time) *Future[NodeCPUCoresAllocatableResult] {
-	m.recordCall("QueryNodeCPUCoresAllocatable")
+	m.recordCall(QueryNodeCPUCoresAllocatable)
 	return m.Querier.QueryNodeCPUCoresAllocatable(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeRAMBytesCapacity(start, end time.Time) *Future[NodeRAMBytesCapacityResult] {
-	m.recordCall("QueryNodeRAMBytesCapacity")
+	m.recordCall(QueryNodeRAMBytesCapacity)
 	return m.Querier.QueryNodeRAMBytesCapacity(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeRAMBytesAllocatable(start, end time.Time) *Future[NodeRAMBytesAllocatableResult] {
-	m.recordCall("QueryNodeRAMBytesAllocatable")
+	m.recordCall(QueryNodeRAMBytesAllocatable)
 	return m.Querier.QueryNodeRAMBytesAllocatable(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeGPUCount(start, end time.Time) *Future[NodeGPUCountResult] {
-	m.recordCall("QueryNodeGPUCount")
+	m.recordCall(QueryNodeGPUCount)
 	return m.Querier.QueryNodeGPUCount(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeCPUModeTotal(start, end time.Time) *Future[NodeCPUModeTotalResult] {
-	m.recordCall("QueryNodeCPUModeTotal")
+	m.recordCall(QueryNodeCPUModeTotal)
 	return m.Querier.QueryNodeCPUModeTotal(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeIsSpot(start, end time.Time) *Future[NodeIsSpotResult] {
-	m.recordCall("QueryNodeIsSpot")
+	m.recordCall(QueryNodeIsSpot)
 	return m.Querier.QueryNodeIsSpot(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeRAMSystemPercent(start, end time.Time) *Future[NodeRAMSystemPercentResult] {
-	m.recordCall("QueryNodeRAMSystemPercent")
+	m.recordCall(QueryNodeRAMSystemPercent)
 	return m.Querier.QueryNodeRAMSystemPercent(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeRAMUserPercent(start, end time.Time) *Future[NodeRAMUserPercentResult] {
-	m.recordCall("QueryNodeRAMUserPercent")
+	m.recordCall(QueryNodeRAMUserPercent)
 	return m.Querier.QueryNodeRAMUserPercent(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeResourceCapacities(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryNodeResourceCapacities")
+	m.recordCall(QueryNodeResourceCapacities)
 	return m.Querier.QueryNodeResourceCapacities(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeResourcesAllocatable(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryNodeResourcesAllocatable")
+	m.recordCall(QueryNodeResourcesAllocatable)
 	return m.Querier.QueryNodeResourcesAllocatable(start, end)
 }
 
 // Load Balancers
 
 func (m *RecordMetricsQuerier) QueryLBActiveMinutes(start, end time.Time) *Future[LBActiveMinutesResult] {
-	m.recordCall("QueryLBActiveMinutes")
+	m.recordCall(QueryLBActiveMinutes)
 	return m.Querier.QueryLBActiveMinutes(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryLBPricePerHr(start, end time.Time) *Future[LBPricePerHrResult] {
-	m.recordCall("QueryLBPricePerHr")
+	m.recordCall(QueryLBPricePerHr)
 	return m.Querier.QueryLBPricePerHr(start, end)
 }
 
 // Cluster Management
 
 func (m *RecordMetricsQuerier) QueryClusterInfo(start, end time.Time) *Future[ClusterInfoResult] {
-	m.recordCall("QueryClusterInfo")
+	m.recordCall(QueryClusterInfo)
 	return m.Querier.QueryClusterInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryClusterUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryClusterUptime")
+	m.recordCall(QueryClusterUptime)
 	return m.Querier.QueryClusterUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryClusterManagementDuration(start, end time.Time) *Future[ClusterManagementDurationResult] {
-	m.recordCall("QueryClusterManagementDuration")
+	m.recordCall(QueryClusterManagementDuration)
 	return m.Querier.QueryClusterManagementDuration(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryClusterManagementPricePerHr(start, end time.Time) *Future[ClusterManagementPricePerHrResult] {
-	m.recordCall("QueryClusterManagementPricePerHr")
+	m.recordCall(QueryClusterManagementPricePerHr)
 	return m.Querier.QueryClusterManagementPricePerHr(start, end)
 }
 
 // Pods
 
 func (m *RecordMetricsQuerier) QueryPods(start, end time.Time) *Future[PodsResult] {
-	m.recordCall("QueryPods")
+	m.recordCall(QueryPods)
 	return m.Querier.QueryPods(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodsUID(start, end time.Time) *Future[PodsResult] {
-	m.recordCall("QueryPodsUID")
+	m.recordCall(QueryPodsUID)
 	return m.Querier.QueryPodsUID(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodInfo(start, end time.Time) *Future[PodInfoResult] {
-	m.recordCall("QueryPodInfo")
+	m.recordCall(QueryPodInfo)
 	return m.Querier.QueryPodInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryPodUptime")
+	m.recordCall(QueryPodUptime)
 	return m.Querier.QueryPodUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodOwners(start, end time.Time) *Future[OwnerResult] {
-	m.recordCall("QueryPodOwners")
+	m.recordCall(QueryPodOwners)
 	return m.Querier.QueryPodOwners(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodPVCVolumes(start, end time.Time) *Future[PodPVCVolumeResult] {
-	m.recordCall("QueryPodPVCVolumes")
+	m.recordCall(QueryPodPVCVolumes)
 	return m.Querier.QueryPodPVCVolumes(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodNetworkEgressBytes(start, end time.Time) *Future[PodNetworkBytesResult] {
-	m.recordCall("QueryPodNetworkEgressBytes")
+	m.recordCall(QueryPodNetworkEgressBytes)
 	return m.Querier.QueryPodNetworkEgressBytes(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodNetworkIngressBytes(start, end time.Time) *Future[PodNetworkBytesResult] {
-	m.recordCall("QueryPodNetworkIngressBytes")
+	m.recordCall(QueryPodNetworkIngressBytes)
 	return m.Querier.QueryPodNetworkIngressBytes(start, end)
 }
 
 // Container
 
 func (m *RecordMetricsQuerier) QueryContainerUptime(start, end time.Time) *Future[ContainerUptimeResult] {
-	m.recordCall("QueryContainerUptime")
+	m.recordCall(QueryContainerUptime)
 	return m.Querier.QueryContainerUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryContainerResourceRequests(start, end time.Time) *Future[ContainerResourceResult] {
-	m.recordCall("QueryContainerResourceRequests")
+	m.recordCall(QueryContainerResourceRequests)
 	return m.Querier.QueryContainerResourceRequests(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryContainerResourceLimits(start, end time.Time) *Future[ContainerResourceResult] {
-	m.recordCall("QueryContainerResourceLimits")
+	m.recordCall(QueryContainerResourceLimits)
 	return m.Querier.QueryContainerResourceLimits(start, end)
 }
 
 // RAM
 
 func (m *RecordMetricsQuerier) QueryRAMBytesAllocated(start, end time.Time) *Future[RAMBytesAllocatedResult] {
-	m.recordCall("QueryRAMBytesAllocated")
+	m.recordCall(QueryRAMBytesAllocated)
 	return m.Querier.QueryRAMBytesAllocated(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryRAMRequests(start, end time.Time) *Future[RAMRequestsResult] {
-	m.recordCall("QueryRAMRequests")
+	m.recordCall(QueryRAMRequests)
 	return m.Querier.QueryRAMRequests(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryRAMLimits(start, end time.Time) *Future[RAMLimitsResult] {
-	m.recordCall("QueryRAMLimits")
+	m.recordCall(QueryRAMLimits)
 	return m.Querier.QueryRAMLimits(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryRAMUsageAvg(start, end time.Time) *Future[RAMUsageAvgResult] {
-	m.recordCall("QueryRAMUsageAvg")
+	m.recordCall(QueryRAMUsageAvg)
 	return m.Querier.QueryRAMUsageAvg(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryRAMUsageMax(start, end time.Time) *Future[RAMUsageMaxResult] {
-	m.recordCall("QueryRAMUsageMax")
+	m.recordCall(QueryRAMUsageMax)
 	return m.Querier.QueryRAMUsageMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeRAMPricePerGiBHr(start, end time.Time) *Future[NodeRAMPricePerGiBHrResult] {
-	m.recordCall("QueryNodeRAMPricePerGiBHr")
+	m.recordCall(QueryNodeRAMPricePerGiBHr)
 	return m.Querier.QueryNodeRAMPricePerGiBHr(start, end)
 }
 
 // CPU
 
 func (m *RecordMetricsQuerier) QueryCPUCoresAllocated(start, end time.Time) *Future[CPUCoresAllocatedResult] {
-	m.recordCall("QueryCPUCoresAllocated")
+	m.recordCall(QueryCPUCoresAllocated)
 	return m.Querier.QueryCPUCoresAllocated(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryCPURequests(start, end time.Time) *Future[CPURequestsResult] {
-	m.recordCall("QueryCPURequests")
+	m.recordCall(QueryCPURequests)
 	return m.Querier.QueryCPURequests(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryCPULimits(start, end time.Time) *Future[CPULimitsResult] {
-	m.recordCall("QueryCPULimits")
+	m.recordCall(QueryCPULimits)
 	return m.Querier.QueryCPULimits(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryCPUUsageAvg(start, end time.Time) *Future[CPUUsageAvgResult] {
-	m.recordCall("QueryCPUUsageAvg")
+	m.recordCall(QueryCPUUsageAvg)
 	return m.Querier.QueryCPUUsageAvg(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryCPUUsageMax(start, end time.Time) *Future[CPUUsageMaxResult] {
-	m.recordCall("QueryCPUUsageMax")
+	m.recordCall(QueryCPUUsageMax)
 	return m.Querier.QueryCPUUsageMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeCPUPricePerHr(start, end time.Time) *Future[NodeCPUPricePerHrResult] {
-	m.recordCall("QueryNodeCPUPricePerHr")
+	m.recordCall(QueryNodeCPUPricePerHr)
 	return m.Querier.QueryNodeCPUPricePerHr(start, end)
 }
 
 // GPU
 
 func (m *RecordMetricsQuerier) QueryGPUsAllocated(start, end time.Time) *Future[GPUsAllocatedResult] {
-	m.recordCall("QueryGPUsAllocated")
+	m.recordCall(QueryGPUsAllocated)
 	return m.Querier.QueryGPUsAllocated(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryGPUsRequested(start, end time.Time) *Future[GPUsRequestedResult] {
-	m.recordCall("QueryGPUsRequested")
+	m.recordCall(QueryGPUsRequested)
 	return m.Querier.QueryGPUsRequested(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryGPUsUsageAvg(start, end time.Time) *Future[GPUsUsageAvgResult] {
-	m.recordCall("QueryGPUsUsageAvg")
+	m.recordCall(QueryGPUsUsageAvg)
 	return m.Querier.QueryGPUsUsageAvg(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryGPUsUsageMax(start, end time.Time) *Future[GPUsUsageMaxResult] {
-	m.recordCall("QueryGPUsUsageMax")
+	m.recordCall(QueryGPUsUsageMax)
 	return m.Querier.QueryGPUsUsageMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNodeGPUPricePerHr(start, end time.Time) *Future[NodeGPUPricePerHrResult] {
-	m.recordCall("QueryNodeGPUPricePerHr")
+	m.recordCall(QueryNodeGPUPricePerHr)
 	return m.Querier.QueryNodeGPUPricePerHr(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryGPUInfo(start, end time.Time) *Future[GPUInfoResult] {
-	m.recordCall("QueryGPUInfo")
+	m.recordCall(QueryGPUInfo)
 	return m.Querier.QueryGPUInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryIsGPUShared(start, end time.Time) *Future[IsGPUSharedResult] {
-	m.recordCall("QueryIsGPUShared")
+	m.recordCall(QueryIsGPUShared)
 	return m.Querier.QueryIsGPUShared(start, end)
 }
 
 // Device
 
 func (m *RecordMetricsQuerier) QueryDCGMDeviceInfo(start, end time.Time) *Future[DCGMDeviceInfoResult] {
-	m.recordCall("QueryDCGMDeviceInfo")
+	m.recordCall(QueryDCGMDeviceInfo)
 	return m.Querier.QueryDCGMDeviceInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDCGMDeviceUptime(start, end time.Time) *Future[DCGMDeviceUptimeResult] {
-	m.recordCall("QueryDCGMDeviceUptime")
+	m.recordCall(QueryDCGMDeviceUptime)
 	return m.Querier.QueryDCGMDeviceUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDCGMContainerUsageAvg(start, end time.Time) *Future[DCGMDeviceContainerUsageResult] {
-	m.recordCall("QueryDCGMContainerUsageAvg")
+	m.recordCall(QueryDCGMContainerUsageAvg)
 	return m.Querier.QueryDCGMContainerUsageAvg(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDCGMContainerUsageMax(start, end time.Time) *Future[DCGMDeviceContainerUsageResult] {
-	m.recordCall("QueryDCGMContainerUsageMax")
+	m.recordCall(QueryDCGMContainerUsageMax)
 	return m.Querier.QueryDCGMContainerUsageMax(start, end)
 }
 
 // PVC
 
 func (m *RecordMetricsQuerier) QueryPodPVCAllocation(start, end time.Time) *Future[PodPVCAllocationResult] {
-	m.recordCall("QueryPodPVCAllocation")
+	m.recordCall(QueryPodPVCAllocation)
 	return m.Querier.QueryPodPVCAllocation(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVCBytesRequested(start, end time.Time) *Future[PVCBytesRequestedResult] {
-	m.recordCall("QueryPVCBytesRequested")
+	m.recordCall(QueryPVCBytesRequested)
 	return m.Querier.QueryPVCBytesRequested(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVCInfo(start, end time.Time) *Future[PVCInfoResult] {
-	m.recordCall("QueryPVCInfo")
+	m.recordCall(QueryPVCInfo)
 	return m.Querier.QueryPVCInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryKMPVCInfo(start, end time.Time) *Future[PVCInfoResult] {
-	m.recordCall("QueryKMPVCInfo")
+	m.recordCall(QueryKMPVCInfo)
 	return m.Querier.QueryKMPVCInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVCUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryPVCUptime")
+	m.recordCall(QueryPVCUptime)
 	return m.Querier.QueryPVCUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVCBytesUsedAverage(start, end time.Time) *Future[PVCUIDValueResult] {
-	m.recordCall("QueryPVCBytesUsedAverage")
+	m.recordCall(QueryPVCBytesUsedAverage)
 	return m.Querier.QueryPVCBytesUsedAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVCBytesUsedMax(start, end time.Time) *Future[PVCUIDValueResult] {
-	m.recordCall("QueryPVCBytesUsedMax")
+	m.recordCall(QueryPVCBytesUsedMax)
 	return m.Querier.QueryPVCBytesUsedMax(start, end)
 }
 
 // PV
 
 func (m *RecordMetricsQuerier) QueryPVBytes(start, end time.Time) *Future[PVBytesResult] {
-	m.recordCall("QueryPVBytes")
+	m.recordCall(QueryPVBytes)
 	return m.Querier.QueryPVBytes(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVPricePerGiBHour(start, end time.Time) *Future[PVPricePerGiBHourResult] {
-	m.recordCall("QueryPVPricePerGiBHour")
+	m.recordCall(QueryPVPricePerGiBHour)
 	return m.Querier.QueryPVPricePerGiBHour(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVInfo(start, end time.Time) *Future[PVInfoResult] {
-	m.recordCall("QueryPVInfo")
+	m.recordCall(QueryPVInfo)
 	return m.Querier.QueryPVInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVActiveMinutes(start, end time.Time) *Future[PVActiveMinutesResult] {
-	m.recordCall("QueryPVActiveMinutes")
+	m.recordCall(QueryPVActiveMinutes)
 	return m.Querier.QueryPVActiveMinutes(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVUsedAverage(start, end time.Time) *Future[PVUsedAvgResult] {
-	m.recordCall("QueryPVUsedAverage")
+	m.recordCall(QueryPVUsedAverage)
 	return m.Querier.QueryPVUsedAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVUsedMax(start, end time.Time) *Future[PVUsedMaxResult] {
-	m.recordCall("QueryPVUsedMax")
+	m.recordCall(QueryPVUsedMax)
 	return m.Querier.QueryPVUsedMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryKMPVInfo(start, end time.Time) *Future[PVInfoResult] {
-	m.recordCall("QueryKMPVInfo")
+	m.recordCall(QueryKMPVInfo)
 	return m.Querier.QueryKMPVInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPVUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryPVUptime")
+	m.recordCall(QueryPVUptime)
 	return m.Querier.QueryPVUptime(start, end)
 }
 
 // Deployment
 
 func (m *RecordMetricsQuerier) QueryDeploymentInfo(start, end time.Time) *Future[DeploymentInfoResult] {
-	m.recordCall("QueryDeploymentInfo")
+	m.recordCall(QueryDeploymentInfo)
 	return m.Querier.QueryDeploymentInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDeploymentUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryDeploymentUptime")
+	m.recordCall(QueryDeploymentUptime)
 	return m.Querier.QueryDeploymentUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDeploymentLabels(start, end time.Time) *Future[LabelsResult] {
-	m.recordCall("QueryDeploymentLabels")
+	m.recordCall(QueryDeploymentLabels)
 	return m.Querier.QueryDeploymentLabels(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDeploymentAnnotations(start, end time.Time) *Future[AnnotationsResult] {
-	m.recordCall("QueryDeploymentAnnotations")
+	m.recordCall(QueryDeploymentAnnotations)
 	return m.Querier.QueryDeploymentAnnotations(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDeploymentMatchLabels(start, end time.Time) *Future[DeploymentLabelsResult] {
-	m.recordCall("QueryDeploymentMatchLabels")
+	m.recordCall(QueryDeploymentMatchLabels)
 	return m.Querier.QueryDeploymentMatchLabels(start, end)
 }
 
 // StatefulSet
 
 func (m *RecordMetricsQuerier) QueryStatefulSetInfo(start, end time.Time) *Future[StatefulSetInfoResult] {
-	m.recordCall("QueryStatefulSetInfo")
+	m.recordCall(QueryStatefulSetInfo)
 	return m.Querier.QueryStatefulSetInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryStatefulSetUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryStatefulSetUptime")
+	m.recordCall(QueryStatefulSetUptime)
 	return m.Querier.QueryStatefulSetUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryStatefulSetLabels(start, end time.Time) *Future[LabelsResult] {
-	m.recordCall("QueryStatefulSetLabels")
+	m.recordCall(QueryStatefulSetLabels)
 	return m.Querier.QueryStatefulSetLabels(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryStatefulSetAnnotations(start, end time.Time) *Future[AnnotationsResult] {
-	m.recordCall("QueryStatefulSetAnnotations")
+	m.recordCall(QueryStatefulSetAnnotations)
 	return m.Querier.QueryStatefulSetAnnotations(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryStatefulSetMatchLabels(start, end time.Time) *Future[StatefulSetLabelsResult] {
-	m.recordCall("QueryStatefulSetMatchLabels")
+	m.recordCall(QueryStatefulSetMatchLabels)
 	return m.Querier.QueryStatefulSetMatchLabels(start, end)
 }
 
 // DaemonSet
 
 func (m *RecordMetricsQuerier) QueryDaemonSetInfo(start, end time.Time) *Future[DaemonSetInfoResult] {
-	m.recordCall("QueryDaemonSetInfo")
+	m.recordCall(QueryDaemonSetInfo)
 	return m.Querier.QueryDaemonSetInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDaemonSetUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryDaemonSetUptime")
+	m.recordCall(QueryDaemonSetUptime)
 	return m.Querier.QueryDaemonSetUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDaemonSetLabels(start, end time.Time) *Future[LabelsResult] {
-	m.recordCall("QueryDaemonSetLabels")
+	m.recordCall(QueryDaemonSetLabels)
 	return m.Querier.QueryDaemonSetLabels(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryDaemonSetAnnotations(start, end time.Time) *Future[AnnotationsResult] {
-	m.recordCall("QueryDaemonSetAnnotations")
+	m.recordCall(QueryDaemonSetAnnotations)
 	return m.Querier.QueryDaemonSetAnnotations(start, end)
 }
 
 // Job
 
 func (m *RecordMetricsQuerier) QueryJobInfo(start, end time.Time) *Future[JobInfoResult] {
-	m.recordCall("QueryJobInfo")
+	m.recordCall(QueryJobInfo)
 	return m.Querier.QueryJobInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryJobUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryJobUptime")
+	m.recordCall(QueryJobUptime)
 	return m.Querier.QueryJobUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryJobLabels(start, end time.Time) *Future[LabelsResult] {
-	m.recordCall("QueryJobLabels")
+	m.recordCall(QueryJobLabels)
 	return m.Querier.QueryJobLabels(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryJobAnnotations(start, end time.Time) *Future[AnnotationsResult] {
-	m.recordCall("QueryJobAnnotations")
+	m.recordCall(QueryJobAnnotations)
 	return m.Querier.QueryJobAnnotations(start, end)
 }
 
 // CronJob
 
 func (m *RecordMetricsQuerier) QueryCronJobInfo(start, end time.Time) *Future[CronJobInfoResult] {
-	m.recordCall("QueryCronJobInfo")
+	m.recordCall(QueryCronJobInfo)
 	return m.Querier.QueryCronJobInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryCronJobUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryCronJobUptime")
+	m.recordCall(QueryCronJobUptime)
 	return m.Querier.QueryCronJobUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryCronJobLabels(start, end time.Time) *Future[LabelsResult] {
-	m.recordCall("QueryCronJobLabels")
+	m.recordCall(QueryCronJobLabels)
 	return m.Querier.QueryCronJobLabels(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryCronJobAnnotations(start, end time.Time) *Future[AnnotationsResult] {
-	m.recordCall("QueryCronJobAnnotations")
+	m.recordCall(QueryCronJobAnnotations)
 	return m.Querier.QueryCronJobAnnotations(start, end)
 }
 
 // ReplicaSet
 
 func (m *RecordMetricsQuerier) QueryReplicaSetInfo(start, end time.Time) *Future[ReplicaSetInfoResult] {
-	m.recordCall("QueryReplicaSetInfo")
+	m.recordCall(QueryReplicaSetInfo)
 	return m.Querier.QueryReplicaSetInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryReplicaSetUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryReplicaSetUptime")
+	m.recordCall(QueryReplicaSetUptime)
 	return m.Querier.QueryReplicaSetUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryReplicaSetLabels(start, end time.Time) *Future[LabelsResult] {
-	m.recordCall("QueryReplicaSetLabels")
+	m.recordCall(QueryReplicaSetLabels)
 	return m.Querier.QueryReplicaSetLabels(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryReplicaSetAnnotations(start, end time.Time) *Future[AnnotationsResult] {
-	m.recordCall("QueryReplicaSetAnnotations")
+	m.recordCall(QueryReplicaSetAnnotations)
 	return m.Querier.QueryReplicaSetAnnotations(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryReplicaSetOwners(start, end time.Time) *Future[OwnerResult] {
-	m.recordCall("QueryReplicaSetOwners")
+	m.recordCall(QueryReplicaSetOwners)
 	return m.Querier.QueryReplicaSetOwners(start, end)
 }
 
 // Namespace
 
 func (m *RecordMetricsQuerier) QueryNamespaceInfo(start, end time.Time) *Future[NamespaceInfoResult] {
-	m.recordCall("QueryNamespaceInfo")
+	m.recordCall(QueryNamespaceInfo)
 	return m.Querier.QueryNamespaceInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNamespaceUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryNamespaceUptime")
+	m.recordCall(QueryNamespaceUptime)
 	return m.Querier.QueryNamespaceUptime(start, end)
 }
 
 // Service
 
 func (m *RecordMetricsQuerier) QueryServiceInfo(start, end time.Time) *Future[ServiceInfoResult] {
-	m.recordCall("QueryServiceInfo")
+	m.recordCall(QueryServiceInfo)
 	return m.Querier.QueryServiceInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryServiceUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryServiceUptime")
+	m.recordCall(QueryServiceUptime)
 	return m.Querier.QueryServiceUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryServiceSelectorLabels(start, end time.Time) *Future[ServiceLabelsResult] {
-	m.recordCall("QueryServiceSelectorLabels")
+	m.recordCall(QueryServiceSelectorLabels)
 	return m.Querier.QueryServiceSelectorLabels(start, end)
 }
 
 // Network Egress
 
 func (m *RecordMetricsQuerier) QueryNetZoneGiB(start, end time.Time) *Future[NetZoneGiBResult] {
-	m.recordCall("QueryNetZoneGiB")
+	m.recordCall(QueryNetZoneGiB)
 	return m.Querier.QueryNetZoneGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetZonePricePerGiB(start, end time.Time) *Future[NetZonePricePerGiBResult] {
-	m.recordCall("QueryNetZonePricePerGiB")
+	m.recordCall(QueryNetZonePricePerGiB)
 	return m.Querier.QueryNetZonePricePerGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetRegionGiB(start, end time.Time) *Future[NetRegionGiBResult] {
-	m.recordCall("QueryNetRegionGiB")
+	m.recordCall(QueryNetRegionGiB)
 	return m.Querier.QueryNetRegionGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetRegionPricePerGiB(start, end time.Time) *Future[NetRegionPricePerGiBResult] {
-	m.recordCall("QueryNetRegionPricePerGiB")
+	m.recordCall(QueryNetRegionPricePerGiB)
 	return m.Querier.QueryNetRegionPricePerGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetInternetGiB(start, end time.Time) *Future[NetInternetGiBResult] {
-	m.recordCall("QueryNetInternetGiB")
+	m.recordCall(QueryNetInternetGiB)
 	return m.Querier.QueryNetInternetGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetInternetPricePerGiB(start, end time.Time) *Future[NetInternetPricePerGiBResult] {
-	m.recordCall("QueryNetInternetPricePerGiB")
+	m.recordCall(QueryNetInternetPricePerGiB)
 	return m.Querier.QueryNetInternetPricePerGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetInternetServiceGiB(start, end time.Time) *Future[NetInternetServiceGiBResult] {
-	m.recordCall("QueryNetInternetServiceGiB")
+	m.recordCall(QueryNetInternetServiceGiB)
 	return m.Querier.QueryNetInternetServiceGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetNatGatewayPricePerGiB(start, end time.Time) *Future[NetNatGatewayPricePerGiBResult] {
-	m.recordCall("QueryNetNatGatewayPricePerGiB")
+	m.recordCall(QueryNetNatGatewayPricePerGiB)
 	return m.Querier.QueryNetNatGatewayPricePerGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetNatGatewayGiB(start, end time.Time) *Future[NetNatGatewayGiBResult] {
-	m.recordCall("QueryNetNatGatewayGiB")
+	m.recordCall(QueryNetNatGatewayGiB)
 	return m.Querier.QueryNetNatGatewayGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetTransferBytes(start, end time.Time) *Future[NetTransferBytesResult] {
-	m.recordCall("QueryNetTransferBytes")
+	m.recordCall(QueryNetTransferBytes)
 	return m.Querier.QueryNetTransferBytes(start, end)
 }
 
 // Network Ingress
 
 func (m *RecordMetricsQuerier) QueryNetZoneIngressGiB(start, end time.Time) *Future[NetZoneIngressGiBResult] {
-	m.recordCall("QueryNetZoneIngressGiB")
+	m.recordCall(QueryNetZoneIngressGiB)
 	return m.Querier.QueryNetZoneIngressGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetRegionIngressGiB(start, end time.Time) *Future[NetRegionIngressGiBResult] {
-	m.recordCall("QueryNetRegionIngressGiB")
+	m.recordCall(QueryNetRegionIngressGiB)
 	return m.Querier.QueryNetRegionIngressGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetInternetIngressGiB(start, end time.Time) *Future[NetInternetIngressGiBResult] {
-	m.recordCall("QueryNetInternetIngressGiB")
+	m.recordCall(QueryNetInternetIngressGiB)
 	return m.Querier.QueryNetInternetIngressGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetInternetServiceIngressGiB(start, end time.Time) *Future[NetInternetServiceIngressGiBResult] {
-	m.recordCall("QueryNetInternetServiceIngressGiB")
+	m.recordCall(QueryNetInternetServiceIngressGiB)
 	return m.Querier.QueryNetInternetServiceIngressGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetNatGatewayIngressPricePerGiB(start, end time.Time) *Future[NetNatGatewayPricePerGiBResult] {
-	m.recordCall("QueryNetNatGatewayIngressPricePerGiB")
+	m.recordCall(QueryNetNatGatewayIngressPricePerGiB)
 	return m.Querier.QueryNetNatGatewayIngressPricePerGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetNatGatewayIngressGiB(start, end time.Time) *Future[NetNatGatewayIngressGiBResult] {
-	m.recordCall("QueryNetNatGatewayIngressGiB")
+	m.recordCall(QueryNetNatGatewayIngressGiB)
 	return m.Querier.QueryNetNatGatewayIngressGiB(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNetReceiveBytes(start, end time.Time) *Future[NetReceiveBytesResult] {
-	m.recordCall("QueryNetReceiveBytes")
+	m.recordCall(QueryNetReceiveBytes)
 	return m.Querier.QueryNetReceiveBytes(start, end)
 }
 
 // Annotations
 
 func (m *RecordMetricsQuerier) QueryNamespaceAnnotations(start, end time.Time) *Future[NamespaceAnnotationsResult] {
-	m.recordCall("QueryNamespaceAnnotations")
+	m.recordCall(QueryNamespaceAnnotations)
 	return m.Querier.QueryNamespaceAnnotations(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodAnnotations(start, end time.Time) *Future[PodAnnotationsResult] {
-	m.recordCall("QueryPodAnnotations")
+	m.recordCall(QueryPodAnnotations)
 	return m.Querier.QueryPodAnnotations(start, end)
 }
 
 // Labels
 
 func (m *RecordMetricsQuerier) QueryNodeLabels(start, end time.Time) *Future[NodeLabelsResult] {
-	m.recordCall("QueryNodeLabels")
+	m.recordCall(QueryNodeLabels)
 	return m.Querier.QueryNodeLabels(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryNamespaceLabels(start, end time.Time) *Future[NamespaceLabelsResult] {
-	m.recordCall("QueryNamespaceLabels")
+	m.recordCall(QueryNamespaceLabels)
 	return m.Querier.QueryNamespaceLabels(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodLabels(start, end time.Time) *Future[PodLabelsResult] {
-	m.recordCall("QueryPodLabels")
+	m.recordCall(QueryPodLabels)
 	return m.Querier.QueryPodLabels(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodsWithDaemonSetOwner(start, end time.Time) *Future[PodsWithDaemonSetOwnerResult] {
-	m.recordCall("QueryPodsWithDaemonSetOwner")
+	m.recordCall(QueryPodsWithDaemonSetOwner)
 	return m.Querier.QueryPodsWithDaemonSetOwner(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryPodsWithJobOwner(start, end time.Time) *Future[PodsWithJobOwnerResult] {
-	m.recordCall("QueryPodsWithJobOwner")
+	m.recordCall(QueryPodsWithJobOwner)
 	return m.Querier.QueryPodsWithJobOwner(start, end)
 }
 
 // ReplicaSet -> Controller mapping
 
 func (m *RecordMetricsQuerier) QueryPodsWithReplicaSetOwner(start, end time.Time) *Future[PodsWithReplicaSetOwnerResult] {
-	m.recordCall("QueryPodsWithReplicaSetOwner")
+	m.recordCall(QueryPodsWithReplicaSetOwner)
 	return m.Querier.QueryPodsWithReplicaSetOwner(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryReplicaSetsWithoutOwners(start, end time.Time) *Future[ReplicaSetsWithoutOwnersResult] {
-	m.recordCall("QueryReplicaSetsWithoutOwners")
+	m.recordCall(QueryReplicaSetsWithoutOwners)
 	return m.Querier.QueryReplicaSetsWithoutOwners(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryReplicaSetsWithRollout(start, end time.Time) *Future[ReplicaSetsWithRolloutResult] {
-	m.recordCall("QueryReplicaSetsWithRollout")
+	m.recordCall(QueryReplicaSetsWithRollout)
 	return m.Querier.QueryReplicaSetsWithRollout(start, end)
 }
 
 // ResourceQuotas
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaInfo(start, end time.Time) *Future[ResourceQuotaInfoResult] {
-	m.recordCall("QueryResourceQuotaInfo")
+	m.recordCall(QueryResourceQuotaInfo)
 	return m.Querier.QueryResourceQuotaInfo(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaUptime(start, end time.Time) *Future[UptimeResult] {
-	m.recordCall("QueryResourceQuotaUptime")
+	m.recordCall(QueryResourceQuotaUptime)
 	return m.Querier.QueryResourceQuotaUptime(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaSpecCPURequestAverage(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaSpecCPURequestAverage")
+	m.recordCall(QueryResourceQuotaSpecCPURequestAverage)
 	return m.Querier.QueryResourceQuotaSpecCPURequestAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaSpecCPURequestMax(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaSpecCPURequestMax")
+	m.recordCall(QueryResourceQuotaSpecCPURequestMax)
 	return m.Querier.QueryResourceQuotaSpecCPURequestMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaSpecRAMRequestAverage(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaSpecRAMRequestAverage")
+	m.recordCall(QueryResourceQuotaSpecRAMRequestAverage)
 	return m.Querier.QueryResourceQuotaSpecRAMRequestAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaSpecRAMRequestMax(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaSpecRAMRequestMax")
+	m.recordCall(QueryResourceQuotaSpecRAMRequestMax)
 	return m.Querier.QueryResourceQuotaSpecRAMRequestMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaSpecCPULimitAverage(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaSpecCPULimitAverage")
+	m.recordCall(QueryResourceQuotaSpecCPULimitAverage)
 	return m.Querier.QueryResourceQuotaSpecCPULimitAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaSpecCPULimitMax(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaSpecCPULimitMax")
+	m.recordCall(QueryResourceQuotaSpecCPULimitMax)
 	return m.Querier.QueryResourceQuotaSpecCPULimitMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaSpecRAMLimitAverage(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaSpecRAMLimitAverage")
+	m.recordCall(QueryResourceQuotaSpecRAMLimitAverage)
 	return m.Querier.QueryResourceQuotaSpecRAMLimitAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaSpecRAMLimitMax(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaSpecRAMLimitMax")
+	m.recordCall(QueryResourceQuotaSpecRAMLimitMax)
 	return m.Querier.QueryResourceQuotaSpecRAMLimitMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaStatusUsedCPURequestAverage(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaStatusUsedCPURequestAverage")
+	m.recordCall(QueryResourceQuotaStatusUsedCPURequestAverage)
 	return m.Querier.QueryResourceQuotaStatusUsedCPURequestAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaStatusUsedCPURequestMax(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaStatusUsedCPURequestMax")
+	m.recordCall(QueryResourceQuotaStatusUsedCPURequestMax)
 	return m.Querier.QueryResourceQuotaStatusUsedCPURequestMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaStatusUsedRAMRequestAverage(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaStatusUsedRAMRequestAverage")
+	m.recordCall(QueryResourceQuotaStatusUsedRAMRequestAverage)
 	return m.Querier.QueryResourceQuotaStatusUsedRAMRequestAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaStatusUsedRAMRequestMax(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaStatusUsedRAMRequestMax")
+	m.recordCall(QueryResourceQuotaStatusUsedRAMRequestMax)
 	return m.Querier.QueryResourceQuotaStatusUsedRAMRequestMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaStatusUsedCPULimitAverage(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaStatusUsedCPULimitAverage")
+	m.recordCall(QueryResourceQuotaStatusUsedCPULimitAverage)
 	return m.Querier.QueryResourceQuotaStatusUsedCPULimitAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaStatusUsedCPULimitMax(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaStatusUsedCPULimitMax")
+	m.recordCall(QueryResourceQuotaStatusUsedCPULimitMax)
 	return m.Querier.QueryResourceQuotaStatusUsedCPULimitMax(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaStatusUsedRAMLimitAverage(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaStatusUsedRAMLimitAverage")
+	m.recordCall(QueryResourceQuotaStatusUsedRAMLimitAverage)
 	return m.Querier.QueryResourceQuotaStatusUsedRAMLimitAverage(start, end)
 }
 
 func (m *RecordMetricsQuerier) QueryResourceQuotaStatusUsedRAMLimitMax(start, end time.Time) *Future[ResourceResult] {
-	m.recordCall("QueryResourceQuotaStatusUsedRAMLimitMax")
+	m.recordCall(QueryResourceQuotaStatusUsedRAMLimitMax)
 	return m.Querier.QueryResourceQuotaStatusUsedRAMLimitMax(start, end)
 }
 
 // Data Coverage Query
 
 func (m *RecordMetricsQuerier) QueryDataCoverage(limitDays int) (time.Time, time.Time, error) {
-	m.recordCall("QueryDataCoverage")
+	m.recordCall(QueryDataCoverage)
 	return m.Querier.QueryDataCoverage(limitDays)
 }