cost-model/core/pkg/source/record.go

package source

import (
	"time"
)

var _ MetricsQuerier = (*RecordMetricsQuerier)(nil)

// 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) QueryClusterKubeModelVersion(start, end time.Time) *Future[ClusterKubeModelVersionResult] {
	m.recordCall(QueryClusterKubeModelVersion)
	return m.Querier.QueryClusterKubeModelVersion(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)
}