add reusable types

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

core/pkg/clusters/mock.go

@@ -0,0 +1,13 @@
+package clusters
+
+type MockClusterInfoProvider struct {
+	clusterInfo map[string]string
+}
+
+func NewMockClusterInfoProvider(clusterInfo map[string]string) *MockClusterInfoProvider {
+	return &MockClusterInfoProvider{clusterInfo: clusterInfo}
+}
+
+func (m *MockClusterInfoProvider) GetClusterInfo() map[string]string {
+	return m.clusterInfo
+}

core/pkg/source/noop.go

@@ -0,0 +1,712 @@
+package source
+
+import (
+	"time"
+)
+
+//--------------------------------------------------------------------------
+//  No-Op MetricsQuerier (empty query results)
+//--------------------------------------------------------------------------
+
+// NoOpMetricsQuerier is a no-op implementation of the MetricsQuerier interface
+// that returns empty results for all queries.
+type NoOpMetricsQuerier struct{}
+
+// NewNoOpMetricsQuerier creates a new mock metrics querier
+func NewNoOpMetricsQuerier() *NoOpMetricsQuerier {
+	return &NoOpMetricsQuerier{}
+}
+
+// Local Cluster Disks
+
+func (m *NoOpMetricsQuerier) QueryLocalStorageActiveMinutes(start, end time.Time) *Future[LocalStorageActiveMinutesResult] {
+	return newEmptyResult(DecodeLocalStorageActiveMinutesResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryLocalStorageUsedAvg(start, end time.Time) *Future[LocalStorageUsedAvgResult] {
+	return newEmptyResult(DecodeLocalStorageUsedAvgResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryLocalStorageUsedMax(start, end time.Time) *Future[LocalStorageUsedMaxResult] {
+	return newEmptyResult(DecodeLocalStorageUsedMaxResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryLocalStorageBytes(start, end time.Time) *Future[LocalStorageBytesResult] {
+	return newEmptyResult(DecodeLocalStorageBytesResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryKMLocalStorageUsedAvg(start, end time.Time) *Future[NodeUIDValueResult] {
+	return newEmptyResult(DecodeNodeUIDValueResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryKMLocalStorageUsedMax(start, end time.Time) *Future[NodeUIDValueResult] {
+	return newEmptyResult(DecodeNodeUIDValueResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryKMLocalStorageBytes(start, end time.Time) *Future[UIDValueResult] {
+	return newEmptyResult(DecodeUIDValueResult)
+}
+
+// Nodes
+
+func (m *NoOpMetricsQuerier) QueryNodeInfo(start, end time.Time) *Future[NodeInfoResult] {
+	return newEmptyResult(DecodeNodeInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeActiveMinutes(start, end time.Time) *Future[NodeActiveMinutesResult] {
+	return newEmptyResult(DecodeNodeActiveMinutesResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeCPUCoresCapacity(start, end time.Time) *Future[NodeCPUCoresCapacityResult] {
+	return newEmptyResult(DecodeNodeCPUCoresCapacityResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeCPUCoresAllocatable(start, end time.Time) *Future[NodeCPUCoresAllocatableResult] {
+	return newEmptyResult(DecodeNodeCPUCoresAllocatableResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeRAMBytesCapacity(start, end time.Time) *Future[NodeRAMBytesCapacityResult] {
+	return newEmptyResult(DecodeNodeRAMBytesCapacityResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeRAMBytesAllocatable(start, end time.Time) *Future[NodeRAMBytesAllocatableResult] {
+	return newEmptyResult(DecodeNodeRAMBytesAllocatableResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeGPUCount(start, end time.Time) *Future[NodeGPUCountResult] {
+	return newEmptyResult(DecodeNodeGPUCountResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeCPUModeTotal(start, end time.Time) *Future[NodeCPUModeTotalResult] {
+	return newEmptyResult(DecodeNodeCPUModeTotalResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeIsSpot(start, end time.Time) *Future[NodeIsSpotResult] {
+	return newEmptyResult(DecodeNodeIsSpotResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeRAMSystemPercent(start, end time.Time) *Future[NodeRAMSystemPercentResult] {
+	return newEmptyResult(DecodeNodeRAMSystemPercentResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeRAMUserPercent(start, end time.Time) *Future[NodeRAMUserPercentResult] {
+	return newEmptyResult(DecodeNodeRAMUserPercentResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeResourceCapacities(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeResourcesAllocatable(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+// Load Balancers
+
+func (m *NoOpMetricsQuerier) QueryLBActiveMinutes(start, end time.Time) *Future[LBActiveMinutesResult] {
+	return newEmptyResult(DecodeLBActiveMinutesResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryLBPricePerHr(start, end time.Time) *Future[LBPricePerHrResult] {
+	return newEmptyResult(DecodeLBPricePerHrResult)
+}
+
+// Cluster Management
+
+func (m *NoOpMetricsQuerier) QueryClusterInfo(start, end time.Time) *Future[ClusterInfoResult] {
+	return newEmptyResult(DecodeClusterInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryClusterUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryClusterManagementDuration(start, end time.Time) *Future[ClusterManagementDurationResult] {
+	return newEmptyResult(DecodeClusterManagementDurationResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryClusterManagementPricePerHr(start, end time.Time) *Future[ClusterManagementPricePerHrResult] {
+	return newEmptyResult(DecodeClusterManagementPricePerHrResult)
+}
+
+// Pods
+
+func (m *NoOpMetricsQuerier) QueryPods(start, end time.Time) *Future[PodsResult] {
+	return newEmptyResult(DecodePodsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodsUID(start, end time.Time) *Future[PodsResult] {
+	return newEmptyResult(DecodePodsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodInfo(start, end time.Time) *Future[PodInfoResult] {
+	return newEmptyResult(DecodePodInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodOwners(start, end time.Time) *Future[OwnerResult] {
+	return newEmptyResult(DecodeOwnerResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodPVCVolumes(start, end time.Time) *Future[PodPVCVolumeResult] {
+	return newEmptyResult(DecodePodPVCVolumeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodNetworkEgressBytes(start, end time.Time) *Future[PodNetworkBytesResult] {
+	return newEmptyResult(DecodePodNetworkBytesResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodNetworkIngressBytes(start, end time.Time) *Future[PodNetworkBytesResult] {
+	return newEmptyResult(DecodePodNetworkBytesResult)
+}
+
+// Container
+
+func (m *NoOpMetricsQuerier) QueryContainerUptime(start, end time.Time) *Future[ContainerUptimeResult] {
+	return newEmptyResult(DecodeContainerUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryContainerResourceRequests(start, end time.Time) *Future[ContainerResourceResult] {
+	return newEmptyResult(DecodeContainerResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryContainerResourceLimits(start, end time.Time) *Future[ContainerResourceResult] {
+	return newEmptyResult(DecodeContainerResourceResult)
+}
+
+// RAM
+
+func (m *NoOpMetricsQuerier) QueryRAMBytesAllocated(start, end time.Time) *Future[RAMBytesAllocatedResult] {
+	return newEmptyResult(DecodeRAMBytesAllocatedResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryRAMRequests(start, end time.Time) *Future[RAMRequestsResult] {
+	return newEmptyResult(DecodeRAMRequestsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryRAMLimits(start, end time.Time) *Future[RAMLimitsResult] {
+	return newEmptyResult(DecodeRAMLimitsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryRAMUsageAvg(start, end time.Time) *Future[RAMUsageAvgResult] {
+	return newEmptyResult(DecodeRAMUsageAvgResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryRAMUsageMax(start, end time.Time) *Future[RAMUsageMaxResult] {
+	return newEmptyResult(DecodeRAMUsageMaxResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeRAMPricePerGiBHr(start, end time.Time) *Future[NodeRAMPricePerGiBHrResult] {
+	return newEmptyResult(DecodeNodeRAMPricePerGiBHrResult)
+}
+
+// CPU
+
+func (m *NoOpMetricsQuerier) QueryCPUCoresAllocated(start, end time.Time) *Future[CPUCoresAllocatedResult] {
+	return newEmptyResult(DecodeCPUCoresAllocatedResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryCPURequests(start, end time.Time) *Future[CPURequestsResult] {
+	return newEmptyResult(DecodeCPURequestsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryCPULimits(start, end time.Time) *Future[CPULimitsResult] {
+	return newEmptyResult(DecodeCPULimitsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryCPUUsageAvg(start, end time.Time) *Future[CPUUsageAvgResult] {
+	return newEmptyResult(DecodeCPUUsageAvgResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryCPUUsageMax(start, end time.Time) *Future[CPUUsageMaxResult] {
+	return newEmptyResult(DecodeCPUUsageMaxResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeCPUPricePerHr(start, end time.Time) *Future[NodeCPUPricePerHrResult] {
+	return newEmptyResult(DecodeNodeCPUPricePerHrResult)
+}
+
+// GPU
+
+func (m *NoOpMetricsQuerier) QueryGPUsAllocated(start, end time.Time) *Future[GPUsAllocatedResult] {
+	return newEmptyResult(DecodeGPUsAllocatedResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryGPUsRequested(start, end time.Time) *Future[GPUsRequestedResult] {
+	return newEmptyResult(DecodeGPUsRequestedResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryGPUsUsageAvg(start, end time.Time) *Future[GPUsUsageAvgResult] {
+	return newEmptyResult(DecodeGPUsUsageAvgResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryGPUsUsageMax(start, end time.Time) *Future[GPUsUsageMaxResult] {
+	return newEmptyResult(DecodeGPUsUsageMaxResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNodeGPUPricePerHr(start, end time.Time) *Future[NodeGPUPricePerHrResult] {
+	return newEmptyResult(DecodeNodeGPUPricePerHrResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryGPUInfo(start, end time.Time) *Future[GPUInfoResult] {
+	return newEmptyResult(DecodeGPUInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryIsGPUShared(start, end time.Time) *Future[IsGPUSharedResult] {
+	return newEmptyResult(DecodeIsGPUSharedResult)
+}
+
+// Device
+
+func (m *NoOpMetricsQuerier) QueryDCGMDeviceInfo(start, end time.Time) *Future[DCGMDeviceInfoResult] {
+	return newEmptyResult(DecodeDCGMDeviceInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDCGMDeviceUptime(start, end time.Time) *Future[DCGMDeviceUptimeResult] {
+	return newEmptyResult(DecodeDCGMDeviceUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDCGMContainerUsageAvg(start, end time.Time) *Future[DCGMDeviceContainerUsageResult] {
+	return newEmptyResult(DecodeDCGMDeviceContainerUsageResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDCGMContainerUsageMax(start, end time.Time) *Future[DCGMDeviceContainerUsageResult] {
+	return newEmptyResult(DecodeDCGMDeviceContainerUsageResult)
+}
+
+// PVC
+
+func (m *NoOpMetricsQuerier) QueryPodPVCAllocation(start, end time.Time) *Future[PodPVCAllocationResult] {
+	return newEmptyResult(DecodePodPVCAllocationResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVCBytesRequested(start, end time.Time) *Future[PVCBytesRequestedResult] {
+	return newEmptyResult(DecodePVCBytesRequestedResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVCInfo(start, end time.Time) *Future[PVCInfoResult] {
+	return newEmptyResult(DecodePVCInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryKMPVCInfo(start, end time.Time) *Future[PVCInfoResult] {
+	return newEmptyResult(DecodePVCInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVCUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVCBytesUsedAverage(start, end time.Time) *Future[PVCUIDValueResult] {
+	return newEmptyResult(DecodePVCUIDValueResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVCBytesUsedMax(start, end time.Time) *Future[PVCUIDValueResult] {
+	return newEmptyResult(DecodePVCUIDValueResult)
+}
+
+// PV
+
+func (m *NoOpMetricsQuerier) QueryPVBytes(start, end time.Time) *Future[PVBytesResult] {
+	return newEmptyResult(DecodePVBytesResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVPricePerGiBHour(start, end time.Time) *Future[PVPricePerGiBHourResult] {
+	return newEmptyResult(DecodePVPricePerGiBHourResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVInfo(start, end time.Time) *Future[PVInfoResult] {
+	return newEmptyResult(DecodePVInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVActiveMinutes(start, end time.Time) *Future[PVActiveMinutesResult] {
+	return newEmptyResult(DecodePVActiveMinutesResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVUsedAverage(start, end time.Time) *Future[PVUsedAvgResult] {
+	return newEmptyResult(DecodePVUsedAvgResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVUsedMax(start, end time.Time) *Future[PVUsedMaxResult] {
+	return newEmptyResult(DecodePVUsedMaxResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryKMPVInfo(start, end time.Time) *Future[PVInfoResult] {
+	return newEmptyResult(DecodePVInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPVUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+// Deployment
+
+func (m *NoOpMetricsQuerier) QueryDeploymentInfo(start, end time.Time) *Future[DeploymentInfoResult] {
+	return newEmptyResult(DecodeDeploymentInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDeploymentUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDeploymentLabels(start, end time.Time) *Future[LabelsResult] {
+	return newEmptyResult(DecodeLabelsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDeploymentAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return newEmptyResult(DecodeAnnotationsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDeploymentMatchLabels(start, end time.Time) *Future[DeploymentLabelsResult] {
+	return newEmptyResult(DecodeDeploymentLabelsResult)
+}
+
+// StatefulSet
+
+func (m *NoOpMetricsQuerier) QueryStatefulSetInfo(start, end time.Time) *Future[StatefulSetInfoResult] {
+	return newEmptyResult(DecodeStatefulSetInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryStatefulSetUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryStatefulSetLabels(start, end time.Time) *Future[LabelsResult] {
+	return newEmptyResult(DecodeLabelsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryStatefulSetAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return newEmptyResult(DecodeAnnotationsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryStatefulSetMatchLabels(start, end time.Time) *Future[StatefulSetLabelsResult] {
+	return newEmptyResult(DecodeStatefulSetLabelsResult)
+}
+
+// DaemonSet
+
+func (m *NoOpMetricsQuerier) QueryDaemonSetInfo(start, end time.Time) *Future[DaemonSetInfoResult] {
+	return newEmptyResult(DecodeDaemonSetInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDaemonSetUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDaemonSetLabels(start, end time.Time) *Future[LabelsResult] {
+	return newEmptyResult(DecodeLabelsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryDaemonSetAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return newEmptyResult(DecodeAnnotationsResult)
+}
+
+// Job
+
+func (m *NoOpMetricsQuerier) QueryJobInfo(start, end time.Time) *Future[JobInfoResult] {
+	return newEmptyResult(DecodeJobInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryJobUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryJobLabels(start, end time.Time) *Future[LabelsResult] {
+	return newEmptyResult(DecodeLabelsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryJobAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return newEmptyResult(DecodeAnnotationsResult)
+}
+
+// CronJob
+
+func (m *NoOpMetricsQuerier) QueryCronJobInfo(start, end time.Time) *Future[CronJobInfoResult] {
+	return newEmptyResult(DecodeCronJobInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryCronJobUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryCronJobLabels(start, end time.Time) *Future[LabelsResult] {
+	return newEmptyResult(DecodeLabelsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryCronJobAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return newEmptyResult(DecodeAnnotationsResult)
+}
+
+// ReplicaSet
+
+func (m *NoOpMetricsQuerier) QueryReplicaSetInfo(start, end time.Time) *Future[ReplicaSetInfoResult] {
+	return newEmptyResult(DecodeReplicaSetInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryReplicaSetUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryReplicaSetLabels(start, end time.Time) *Future[LabelsResult] {
+	return newEmptyResult(DecodeLabelsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryReplicaSetAnnotations(start, end time.Time) *Future[AnnotationsResult] {
+	return newEmptyResult(DecodeAnnotationsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryReplicaSetOwners(start, end time.Time) *Future[OwnerResult] {
+	return newEmptyResult(DecodeOwnerResult)
+}
+
+// Namespace
+
+func (m *NoOpMetricsQuerier) QueryNamespaceInfo(start, end time.Time) *Future[NamespaceInfoResult] {
+	return newEmptyResult(DecodeNamespaceInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNamespaceUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+// Service
+
+func (m *NoOpMetricsQuerier) QueryServiceInfo(start, end time.Time) *Future[ServiceInfoResult] {
+	return newEmptyResult(DecodeServiceInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryServiceUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryServiceSelectorLabels(start, end time.Time) *Future[ServiceLabelsResult] {
+	return newEmptyResult(DecodeServiceLabelsResult)
+}
+
+// Network Egress
+
+func (m *NoOpMetricsQuerier) QueryNetZoneGiB(start, end time.Time) *Future[NetZoneGiBResult] {
+	return newEmptyResult(DecodeNetZoneGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetZonePricePerGiB(start, end time.Time) *Future[NetZonePricePerGiBResult] {
+	return newEmptyResult(DecodeNetZonePricePerGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetRegionGiB(start, end time.Time) *Future[NetRegionGiBResult] {
+	return newEmptyResult(DecodeNetRegionGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetRegionPricePerGiB(start, end time.Time) *Future[NetRegionPricePerGiBResult] {
+	return newEmptyResult(DecodeNetRegionPricePerGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetInternetGiB(start, end time.Time) *Future[NetInternetGiBResult] {
+	return newEmptyResult(DecodeNetInternetGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetInternetPricePerGiB(start, end time.Time) *Future[NetInternetPricePerGiBResult] {
+	return newEmptyResult(DecodeNetInternetPricePerGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetInternetServiceGiB(start, end time.Time) *Future[NetInternetServiceGiBResult] {
+	return newEmptyResult(DecodeNetInternetServiceGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetNatGatewayPricePerGiB(start, end time.Time) *Future[NetNatGatewayPricePerGiBResult] {
+	return newEmptyResult(DecodeNetNatGatewayPricePerGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetNatGatewayGiB(start, end time.Time) *Future[NetNatGatewayGiBResult] {
+	return newEmptyResult(DecodeNetNatGatewayGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetTransferBytes(start, end time.Time) *Future[NetTransferBytesResult] {
+	return newEmptyResult(DecodeNetTransferBytesResult)
+}
+
+// Network Ingress
+
+func (m *NoOpMetricsQuerier) QueryNetZoneIngressGiB(start, end time.Time) *Future[NetZoneIngressGiBResult] {
+	return newEmptyResult(DecodeNetZoneIngressGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetRegionIngressGiB(start, end time.Time) *Future[NetRegionIngressGiBResult] {
+	return newEmptyResult(DecodeNetRegionIngressGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetInternetIngressGiB(start, end time.Time) *Future[NetInternetIngressGiBResult] {
+	return newEmptyResult(DecodeNetInternetIngressGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetInternetServiceIngressGiB(start, end time.Time) *Future[NetInternetServiceIngressGiBResult] {
+	return newEmptyResult(DecodeNetInternetServiceIngressGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetNatGatewayIngressPricePerGiB(start, end time.Time) *Future[NetNatGatewayPricePerGiBResult] {
+	return newEmptyResult(DecodeNetNatGatewayPricePerGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetNatGatewayIngressGiB(start, end time.Time) *Future[NetNatGatewayIngressGiBResult] {
+	return newEmptyResult(DecodeNetNatGatewayIngressGiBResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNetReceiveBytes(start, end time.Time) *Future[NetReceiveBytesResult] {
+	return newEmptyResult(DecodeNetReceiveBytesResult)
+}
+
+// Annotations
+
+func (m *NoOpMetricsQuerier) QueryNamespaceAnnotations(start, end time.Time) *Future[NamespaceAnnotationsResult] {
+	return newEmptyResult(DecodeNamespaceAnnotationsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodAnnotations(start, end time.Time) *Future[PodAnnotationsResult] {
+	return newEmptyResult(DecodePodAnnotationsResult)
+}
+
+// Labels
+
+func (m *NoOpMetricsQuerier) QueryNodeLabels(start, end time.Time) *Future[NodeLabelsResult] {
+	return newEmptyResult(DecodeNodeLabelsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryNamespaceLabels(start, end time.Time) *Future[NamespaceLabelsResult] {
+	return newEmptyResult(DecodeNamespaceLabelsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodLabels(start, end time.Time) *Future[PodLabelsResult] {
+	return newEmptyResult(DecodePodLabelsResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodsWithDaemonSetOwner(start, end time.Time) *Future[PodsWithDaemonSetOwnerResult] {
+	return newEmptyResult(DecodePodsWithDaemonSetOwnerResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryPodsWithJobOwner(start, end time.Time) *Future[PodsWithJobOwnerResult] {
+	return newEmptyResult(DecodePodsWithJobOwnerResult)
+}
+
+// ReplicaSet -> Controller mapping
+
+func (m *NoOpMetricsQuerier) QueryPodsWithReplicaSetOwner(start, end time.Time) *Future[PodsWithReplicaSetOwnerResult] {
+	return newEmptyResult(DecodePodsWithReplicaSetOwnerResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryReplicaSetsWithoutOwners(start, end time.Time) *Future[ReplicaSetsWithoutOwnersResult] {
+	return newEmptyResult(DecodeReplicaSetsWithoutOwnersResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryReplicaSetsWithRollout(start, end time.Time) *Future[ReplicaSetsWithRolloutResult] {
+	return newEmptyResult(DecodeReplicaSetsWithRolloutResult)
+}
+
+// ResourceQuotas
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaInfo(start, end time.Time) *Future[ResourceQuotaInfoResult] {
+	return newEmptyResult(DecodeResourceQuotaInfoResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaUptime(start, end time.Time) *Future[UptimeResult] {
+	return newEmptyResult(DecodeUptimeResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaSpecCPURequestAverage(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaSpecCPURequestMax(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaSpecRAMRequestAverage(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaSpecRAMRequestMax(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaSpecCPULimitAverage(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaSpecCPULimitMax(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaSpecRAMLimitAverage(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaSpecRAMLimitMax(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaStatusUsedCPURequestAverage(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaStatusUsedCPURequestMax(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaStatusUsedRAMRequestAverage(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaStatusUsedRAMRequestMax(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaStatusUsedCPULimitAverage(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaStatusUsedCPULimitMax(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaStatusUsedRAMLimitAverage(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryResourceQuotaStatusUsedRAMLimitMax(start, end time.Time) *Future[ResourceResult] {
+	return newEmptyResult(DecodeResourceResult)
+}
+
+// Data Coverage Query
+
+func (m *NoOpMetricsQuerier) QueryDataCoverage(_ int) (time.Time, time.Time, error) {
+	return time.Time{}, time.Time{}, nil
+}
+
+// Extra methods not in MetricsQuerier interface
+
+func (m *NoOpMetricsQuerier) QueryLocalStorageCost(start, end time.Time) *Future[LocalStorageCostResult] {
+	return newEmptyResult(DecodeLocalStorageCostResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryLocalStorageUsedCost(start, end time.Time) *Future[LocalStorageUsedCostResult] {
+	return newEmptyResult(DecodeLocalStorageUsedCostResult)
+}
+
+func (m *NoOpMetricsQuerier) QueryServiceLabels(start, end time.Time) *Future[ServiceLabelsResult] {
+	return newEmptyResult(DecodeServiceLabelsResult)
+}
+
+func newEmptyResult[T any](decoder ResultDecoder[T]) *Future[T] {
+	ch := make(QueryResultsChan)
+	go func() {
+		results := NewQueryResults("")
+		ch <- results
+	}()
+
+	return NewFuture(decoder, ch)
+}

core/pkg/source/record.go

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