cost-model/modules/collector-source/pkg/collector/metricsquerier.go

package collector

import (
	"fmt"
	"time"

	"github.com/opencost/opencost/core/pkg/source"
	"github.com/opencost/opencost/modules/collector-source/pkg/metric"
	"github.com/opencost/opencost/modules/collector-source/pkg/util"
)

const GiB = 1024 * 1024 * 1024
const LocalStorageCostPerGiBHr = 0.04 / 730.0

type collectorMetricsQuerier struct {
	collectorProvider StoreProvider
}

func newCollectorMetricsQuerier(repo *metric.MetricRepository, resoluationConfigs []util.ResolutionConfiguration) *collectorMetricsQuerier {
	return &collectorMetricsQuerier{
		collectorProvider: newRepoStoreProvider(repo, resoluationConfigs),
	}
}

func queryCollector[T any](c *collectorMetricsQuerier, start, end time.Time, id metric.MetricCollectorID, decoder source.ResultDecoder[T]) *source.Future[T] {
	queryResults := source.NewQueryResults(string(id))
	collector := c.collectorProvider.GetStore(start, end)
	if collector != nil {
		results, err := collector.Query(id)
		queryResults.Error = err
		for _, result := range results {
			queryResults.Results = append(queryResults.Results, result.ToQueryResult())
		}
	}
	ch := make(source.QueryResultsChan, 1)
	ch <- queryResults
	f := source.NewFuture[T](decoder, ch)
	return f

}

func queryCollectorGiB[T any](c *collectorMetricsQuerier, start, end time.Time, id metric.MetricCollectorID, decoder source.ResultDecoder[T]) *source.Future[T] {
	queryResults := source.NewQueryResults(string(id))
	collector := c.collectorProvider.GetStore(start, end)
	if collector != nil {
		results, err := collector.Query(id)
		queryResults.Error = err
		for _, result := range results {
			for i := range result.Values {
				result.Values[i].Value /= GiB
			}
			queryResults.Results = append(queryResults.Results, result.ToQueryResult())
		}
	}
	ch := make(source.QueryResultsChan, 1)
	ch <- queryResults
	f := source.NewFuture[T](decoder, ch)
	return f

}

func (c *collectorMetricsQuerier) QueryPVActiveMinutes(start, end time.Time) *source.Future[source.PVActiveMinutesResult] {
	return queryCollector(c, start, end, metric.PVActiveMinutesID, source.DecodePVActiveMinutesResult)
}

func (c *collectorMetricsQuerier) QueryPVUsedAverage(start, end time.Time) *source.Future[source.PVUsedAvgResult] {
	return queryCollector(c, start, end, metric.PVUsedAverageID, source.DecodePVUsedAvgResult)
}

func (c *collectorMetricsQuerier) QueryPVUsedMax(start, end time.Time) *source.Future[source.PVUsedMaxResult] {
	return queryCollector(c, start, end, metric.PVUsedMaxID, source.DecodePVUsedMaxResult)
}

func (c *collectorMetricsQuerier) QueryLocalStorageActiveMinutes(start, end time.Time) *source.Future[source.LocalStorageActiveMinutesResult] {
	return queryCollector(c, start, end, metric.LocalStorageActiveMinutesID, source.DecodeLocalStorageActiveMinutesResult)
}

func (c *collectorMetricsQuerier) QueryLocalStorageUsedAvg(start, end time.Time) *source.Future[source.LocalStorageUsedAvgResult] {
	return queryCollector(c, start, end, metric.LocalStorageUsedAverageID, source.DecodeLocalStorageUsedAvgResult)
}

func (c *collectorMetricsQuerier) QueryLocalStorageUsedMax(start, end time.Time) *source.Future[source.LocalStorageUsedMaxResult] {
	return queryCollector(c, start, end, metric.LocalStorageUsedMaxID, source.DecodeLocalStorageUsedMaxResult)
}

func (c *collectorMetricsQuerier) QueryLocalStorageBytes(start, end time.Time) *source.Future[source.LocalStorageBytesResult] {
	return queryCollector(c, start, end, metric.LocalStorageBytesID, source.DecodeLocalStorageBytesResult)
}

func (c *collectorMetricsQuerier) QueryNodeInfo(start, end time.Time) *source.Future[source.NodeInfoResult] {
	return queryCollector(c, start, end, metric.NodeInfoID, source.DecodeNodeInfoResult)
}

func (c *collectorMetricsQuerier) QueryNodeUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.NodeUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryNodeActiveMinutes(start, end time.Time) *source.Future[source.NodeActiveMinutesResult] {
	return queryCollector(c, start, end, metric.NodeActiveMinutesID, source.DecodeNodeActiveMinutesResult)
}

func (c *collectorMetricsQuerier) QueryNodeCPUCoresCapacity(start, end time.Time) *source.Future[source.NodeCPUCoresCapacityResult] {
	return queryCollector(c, start, end, metric.NodeCPUCoresCapacityID, source.DecodeNodeCPUCoresCapacityResult)

}

func (c *collectorMetricsQuerier) QueryNodeCPUCoresAllocatable(start, end time.Time) *source.Future[source.NodeCPUCoresAllocatableResult] {
	return queryCollector(c, start, end, metric.NodeCPUCoresAllocatableID, source.DecodeNodeCPUCoresAllocatableResult)
}

func (c *collectorMetricsQuerier) QueryNodeRAMBytesCapacity(start, end time.Time) *source.Future[source.NodeRAMBytesCapacityResult] {
	return queryCollector(c, start, end, metric.NodeRAMBytesCapacityID, source.DecodeNodeRAMBytesCapacityResult)
}

func (c *collectorMetricsQuerier) QueryNodeRAMBytesAllocatable(start, end time.Time) *source.Future[source.NodeRAMBytesAllocatableResult] {
	return queryCollector(c, start, end, metric.NodeRAMBytesAllocatableID, source.DecodeNodeRAMBytesAllocatableResult)
}

func (c *collectorMetricsQuerier) QueryNodeGPUCount(start, end time.Time) *source.Future[source.NodeGPUCountResult] {
	return queryCollector(c, start, end, metric.NodeGPUCountID, source.DecodeNodeGPUCountResult)
}

func (c *collectorMetricsQuerier) QueryNodeCPUModeTotal(start, end time.Time) *source.Future[source.NodeCPUModeTotalResult] {
	return queryCollector(c, start, end, metric.NodeCPUModeTotalID, source.DecodeNodeCPUModeTotalResult)
}

func (c *collectorMetricsQuerier) QueryNodeIsSpot(start, end time.Time) *source.Future[source.NodeIsSpotResult] {
	return queryCollector(c, start, end, metric.NodeIsSpotID, source.DecodeNodeIsSpotResult)
}

func (c *collectorMetricsQuerier) QueryNodeRAMSystemPercent(start, end time.Time) *source.Future[source.NodeRAMSystemPercentResult] {
	queryResults := source.NewQueryResults("NodeRAMSystemPercent")
	collector := c.collectorProvider.GetStore(start, end)
	if collector != nil {
		capacityResult, err := collector.Query(metric.NodeRAMBytesCapacityID)
		if err != nil {
			queryResults.Error = err
		}
		nodeCapacities := map[string]float64{}
		for _, result := range capacityResult {
			node := result.MetricLabels[source.NodeLabel]
			if node == "" || len(result.Values) == 0 {
				continue
			}
			nodeCapacities[node] = result.Values[0].Value
		}

		results, err := collector.Query(metric.NodeRAMSystemUsageAverageID)
		if err != nil {
			queryResults.Error = err
		}
		for _, result := range results {
			instance := result.MetricLabels[source.InstanceLabel]

			capacity, ok := nodeCapacities[instance]
			if !ok || len(result.Values) == 0 {
				continue
			}
			result.Values[0].Value /= capacity
			queryResults.Results = append(queryResults.Results, result.ToQueryResult())
		}
	}
	ch := make(source.QueryResultsChan, 1)
	ch <- queryResults
	f := source.NewFuture(source.DecodeNodeRAMSystemPercentResult, ch)
	return f
}

func (c *collectorMetricsQuerier) QueryNodeRAMUserPercent(start, end time.Time) *source.Future[source.NodeRAMUserPercentResult] {
	queryResults := source.NewQueryResults("NodeRAMUserPercent")
	collector := c.collectorProvider.GetStore(start, end)
	if collector != nil {
		capacityResult, err := collector.Query(metric.NodeRAMBytesCapacityID)
		if err != nil {
			queryResults.Error = err
		}
		nodeCapacities := map[string]float64{}
		for _, result := range capacityResult {
			node := result.MetricLabels[source.NodeLabel]
			if node == "" || len(result.Values) == 0 {
				continue
			}
			nodeCapacities[node] = result.Values[0].Value
		}

		results, err := collector.Query(metric.NodeRAMUserUsageAverageID)
		if err != nil {
			queryResults.Error = err
		}
		for _, result := range results {
			instance := result.MetricLabels[source.InstanceLabel]

			capacity, ok := nodeCapacities[instance]
			if !ok || len(result.Values) == 0 {
				continue
			}
			result.Values[0].Value /= capacity
			queryResults.Results = append(queryResults.Results, result.ToQueryResult())
		}
	}
	ch := make(source.QueryResultsChan, 1)
	ch <- queryResults
	f := source.NewFuture(source.DecodeNodeRAMUserPercentResult, ch)
	return f
}

func (c *collectorMetricsQuerier) QueryNodeResourceCapacities(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.NodeResourceCapacitiesID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryNodeResourcesAllocatable(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.NodeResourcesAllocatableID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryLBActiveMinutes(start, end time.Time) *source.Future[source.LBActiveMinutesResult] {
	return queryCollector(c, start, end, metric.LBActiveMinutesID, source.DecodeLBActiveMinutesResult)
}

func (c *collectorMetricsQuerier) QueryLBPricePerHr(start, end time.Time) *source.Future[source.LBPricePerHrResult] {
	return queryCollector(c, start, end, metric.LBPricePerHourID, source.DecodeLBPricePerHrResult)
}

func (c *collectorMetricsQuerier) QueryClusterInfo(start, end time.Time) *source.Future[source.ClusterInfoResult] {
	return queryCollector(c, start, end, metric.ClusterInfoID, source.DecodeClusterInfoResult)
}

func (c *collectorMetricsQuerier) QueryClusterKubeModelVersion(start, end time.Time) *source.Future[source.ClusterKubeModelVersionResult] {
	return queryCollector(c, start, end, metric.ClusterCompleteKubeModelID, source.DecodeClusterKubeModelVersionResult)
}

func (c *collectorMetricsQuerier) QueryClusterUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.ClusterUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryClusterManagementDuration(start, end time.Time) *source.Future[source.ClusterManagementDurationResult] {
	return queryCollector(c, start, end, metric.ClusterManagementDurationID, source.DecodeClusterManagementDurationResult)
}

func (c *collectorMetricsQuerier) QueryClusterManagementPricePerHr(start, end time.Time) *source.Future[source.ClusterManagementPricePerHrResult] {
	return queryCollector(c, start, end, metric.ClusterManagementPricePerHourID, source.DecodeClusterManagementPricePerHrResult)
}

func (c *collectorMetricsQuerier) QueryPods(start, end time.Time) *source.Future[source.PodsResult] {
	return queryCollector(c, start, end, metric.PodActiveMinutesID, source.DecodePodsResult)

}

func (c *collectorMetricsQuerier) QueryPodsUID(start, end time.Time) *source.Future[source.PodsResult] {
	return queryCollector(c, start, end, metric.PodActiveMinutesID, source.DecodePodsResult)
}

func (c *collectorMetricsQuerier) QueryPodInfo(start, end time.Time) *source.Future[source.PodInfoResult] {
	return queryCollector(c, start, end, metric.PodInfoID, source.DecodePodInfoResult)
}

func (c *collectorMetricsQuerier) QueryPodUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.PodUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryPodOwners(start, end time.Time) *source.Future[source.OwnerResult] {
	return queryCollector(c, start, end, metric.PodOwnerID, source.DecodeOwnerResult)
}

func (c *collectorMetricsQuerier) QueryPodPVCVolumes(start, end time.Time) *source.Future[source.PodPVCVolumeResult] {
	return queryCollector(c, start, end, metric.PodPVCVolumeID, source.DecodePodPVCVolumeResult)
}

func (c *collectorMetricsQuerier) QueryPodNetworkEgressBytes(start, end time.Time) *source.Future[source.PodNetworkBytesResult] {
	return queryCollector(c, start, end, metric.PodNetworkEgressBytesID, source.DecodePodNetworkBytesResult)
}

func (c *collectorMetricsQuerier) QueryPodNetworkIngressBytes(start, end time.Time) *source.Future[source.PodNetworkBytesResult] {
	return queryCollector(c, start, end, metric.PodNetworkIngressBytesID, source.DecodePodNetworkBytesResult)
}

func (c *collectorMetricsQuerier) QueryContainerUptime(start, end time.Time) *source.Future[source.ContainerUptimeResult] {
	return queryCollector(c, start, end, metric.ContainerUptimeID, source.DecodeContainerUptimeResult)
}

func (c *collectorMetricsQuerier) QueryContainerResourceRequests(start, end time.Time) *source.Future[source.ContainerResourceResult] {
	return queryCollector(c, start, end, metric.ContainerResourceRequestsID, source.DecodeContainerResourceResult)
}

func (c *collectorMetricsQuerier) QueryContainerResourceLimits(start, end time.Time) *source.Future[source.ContainerResourceResult] {
	return queryCollector(c, start, end, metric.ContainerResourceLimitsID, source.DecodeContainerResourceResult)
}

func (c *collectorMetricsQuerier) QueryRAMBytesAllocated(start, end time.Time) *source.Future[source.RAMBytesAllocatedResult] {
	return queryCollector(c, start, end, metric.RAMBytesAllocatedID, source.DecodeRAMBytesAllocatedResult)
}

func (c *collectorMetricsQuerier) QueryRAMRequests(start, end time.Time) *source.Future[source.RAMRequestsResult] {
	return queryCollector(c, start, end, metric.RAMRequestsID, source.DecodeRAMRequestsResult)
}

func (c *collectorMetricsQuerier) QueryRAMLimits(start, end time.Time) *source.Future[source.RAMLimitsResult] {
	return queryCollector(c, start, end, metric.RAMLimitsID, source.DecodeRAMLimitsResult)
}

func (c *collectorMetricsQuerier) QueryRAMUsageAvg(start, end time.Time) *source.Future[source.RAMUsageAvgResult] {
	return queryCollector(c, start, end, metric.RAMUsageAverageID, source.DecodeRAMUsageAvgResult)
}

func (c *collectorMetricsQuerier) QueryRAMUsageMax(start, end time.Time) *source.Future[source.RAMUsageMaxResult] {
	return queryCollector(c, start, end, metric.RAMUsageMaxID, source.DecodeRAMUsageMaxResult)
}

func (c *collectorMetricsQuerier) QueryNodeRAMPricePerGiBHr(start, end time.Time) *source.Future[source.NodeRAMPricePerGiBHrResult] {
	return queryCollector(c, start, end, metric.NodeRAMPricePerGiBHourID, source.DecodeNodeRAMPricePerGiBHrResult)
}

func (c *collectorMetricsQuerier) QueryCPUCoresAllocated(start, end time.Time) *source.Future[source.CPUCoresAllocatedResult] {
	return queryCollector(c, start, end, metric.CPUCoresAllocatedID, source.DecodeCPUCoresAllocatedResult)
}

func (c *collectorMetricsQuerier) QueryCPURequests(start, end time.Time) *source.Future[source.CPURequestsResult] {
	return queryCollector(c, start, end, metric.CPURequestsID, source.DecodeCPURequestsResult)
}

func (c *collectorMetricsQuerier) QueryCPULimits(start, end time.Time) *source.Future[source.CPULimitsResult] {
	return queryCollector(c, start, end, metric.CPULimitsID, source.DecodeCPULimitsResult)
}

func (c *collectorMetricsQuerier) QueryCPUUsageAvg(start, end time.Time) *source.Future[source.CPUUsageAvgResult] {
	return queryCollector(c, start, end, metric.CPUUsageAverageID, source.DecodeCPUUsageAvgResult)
}

func (c *collectorMetricsQuerier) QueryCPUUsageMax(start, end time.Time) *source.Future[source.CPUUsageMaxResult] {
	return queryCollector(c, start, end, metric.CPUUsageMaxID, source.DecodeCPUUsageMaxResult)
}

func (c *collectorMetricsQuerier) QueryNodeCPUPricePerHr(start, end time.Time) *source.Future[source.NodeCPUPricePerHrResult] {
	return queryCollector(c, start, end, metric.NodeCPUPricePerHourID, source.DecodeNodeCPUPricePerHrResult)
}

func (c *collectorMetricsQuerier) QueryGPUsAllocated(start, end time.Time) *source.Future[source.GPUsAllocatedResult] {
	return queryCollector(c, start, end, metric.GPUsAllocatedID, source.DecodeGPUsAllocatedResult)
}

func (c *collectorMetricsQuerier) QueryGPUsRequested(start, end time.Time) *source.Future[source.GPUsRequestedResult] {
	return queryCollector(c, start, end, metric.GPUsRequestedID, source.DecodeGPUsRequestedResult)
}

func (c *collectorMetricsQuerier) QueryGPUsUsageAvg(start, end time.Time) *source.Future[source.GPUsUsageAvgResult] {
	return queryCollector(c, start, end, metric.GPUsUsageAverageID, source.DecodeGPUsUsageAvgResult)
}

func (c *collectorMetricsQuerier) QueryGPUsUsageMax(start, end time.Time) *source.Future[source.GPUsUsageMaxResult] {
	return queryCollector(c, start, end, metric.GPUsUsageMaxID, source.DecodeGPUsUsageMaxResult)
}

func (c *collectorMetricsQuerier) QueryNodeGPUPricePerHr(start, end time.Time) *source.Future[source.NodeGPUPricePerHrResult] {
	return queryCollector(c, start, end, metric.NodeGPUPricePerHourID, source.DecodeNodeGPUPricePerHrResult)
}

func (c *collectorMetricsQuerier) QueryGPUInfo(start, end time.Time) *source.Future[source.GPUInfoResult] {
	return queryCollector(c, start, end, metric.GPUInfoID, source.DecodeGPUInfoResult)
}

func (c *collectorMetricsQuerier) QueryIsGPUShared(start, end time.Time) *source.Future[source.IsGPUSharedResult] {
	return queryCollector(c, start, end, metric.IsGPUSharedID, source.DecodeIsGPUSharedResult)
}

func (c *collectorMetricsQuerier) QueryDCGMDeviceInfo(start, end time.Time) *source.Future[source.DCGMDeviceInfoResult] {
	return queryCollector(c, start, end, metric.DCGMInfoID, source.DecodeDCGMDeviceInfoResult)
}

func (c *collectorMetricsQuerier) QueryDCGMDeviceUptime(start, end time.Time) *source.Future[source.DCGMDeviceUptimeResult] {
	return queryCollector(c, start, end, metric.DCGMUptimeID, source.DecodeDCGMDeviceUptimeResult)
}

func (c *collectorMetricsQuerier) QueryDCGMContainerUsageAvg(start, end time.Time) *source.Future[source.DCGMDeviceContainerUsageResult] {
	return queryCollector(c, start, end, metric.DCGMContainerUsageAvgID, source.DecodeDCGMDeviceContainerUsageResult)
}

func (c *collectorMetricsQuerier) QueryDCGMContainerUsageMax(start, end time.Time) *source.Future[source.DCGMDeviceContainerUsageResult] {
	return queryCollector(c, start, end, metric.DCGMContainerUsageMaxID, source.DecodeDCGMDeviceContainerUsageResult)
}

func (c *collectorMetricsQuerier) QueryPodPVCAllocation(start, end time.Time) *source.Future[source.PodPVCAllocationResult] {
	return queryCollector(c, start, end, metric.PodPVCAllocationID, source.DecodePodPVCAllocationResult)
}

func (c *collectorMetricsQuerier) QueryPVCBytesRequested(start, end time.Time) *source.Future[source.PVCBytesRequestedResult] {
	return queryCollector(c, start, end, metric.PVCBytesRequestedID, source.DecodePVCBytesRequestedResult)
}

func (c *collectorMetricsQuerier) QueryPVCInfo(start, end time.Time) *source.Future[source.PVCInfoResult] {
	return queryCollector(c, start, end, metric.PVCInfoID, source.DecodePVCInfoResult)
}

func (c *collectorMetricsQuerier) QueryKMPVCInfo(start, end time.Time) *source.Future[source.PVCInfoResult] {
	return queryCollector(c, start, end, metric.KMPVCInfoID, source.DecodePVCInfoResult)
}

func (c *collectorMetricsQuerier) QueryKMLocalStorageUsedAvg(start, end time.Time) *source.Future[source.NodeUIDValueResult] {
	return queryCollector(c, start, end, metric.KMLocalStorageUsedAverageID, source.DecodeNodeUIDValueResult)
}

func (c *collectorMetricsQuerier) QueryKMLocalStorageUsedMax(start, end time.Time) *source.Future[source.NodeUIDValueResult] {
	return queryCollector(c, start, end, metric.KMLocalStorageUsedMaxID, source.DecodeNodeUIDValueResult)
}

func (c *collectorMetricsQuerier) QueryKMLocalStorageBytes(start, end time.Time) *source.Future[source.UIDValueResult] {
	return queryCollector(c, start, end, metric.KMLocalStorageBytesID, source.DecodeUIDValueResult)
}

func (c *collectorMetricsQuerier) QueryPVCUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.PVCUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryPVBytes(start, end time.Time) *source.Future[source.PVBytesResult] {
	return queryCollector(c, start, end, metric.PVBytesID, source.DecodePVBytesResult)
}

func (c *collectorMetricsQuerier) QueryPVPricePerGiBHour(start, end time.Time) *source.Future[source.PVPricePerGiBHourResult] {
	return queryCollector(c, start, end, metric.PVPricePerGiBHourID, source.DecodePVPricePerGiBHourResult)
}

func (c *collectorMetricsQuerier) QueryPVInfo(start, end time.Time) *source.Future[source.PVInfoResult] {
	return queryCollector(c, start, end, metric.PVInfoID, source.DecodePVInfoResult)
}

func (c *collectorMetricsQuerier) QueryKMPVInfo(start, end time.Time) *source.Future[source.PVInfoResult] {
	return queryCollector(c, start, end, metric.KMPVInfoID, source.DecodePVInfoResult)
}

func (c *collectorMetricsQuerier) QueryPVCBytesUsedAverage(start, end time.Time) *source.Future[source.PVCUIDValueResult] {
	return queryCollector(c, start, end, metric.PVCBytesUsedAverageID, source.DecodePVCUIDValueResult)
}

func (c *collectorMetricsQuerier) QueryPVCBytesUsedMax(start, end time.Time) *source.Future[source.PVCUIDValueResult] {
	return queryCollector(c, start, end, metric.PVCBytesUsedMaxID, source.DecodePVCUIDValueResult)
}

func (c *collectorMetricsQuerier) QueryPVUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.PVUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryNamespaceInfo(start, end time.Time) *source.Future[source.NamespaceInfoResult] {
	return queryCollector(c, start, end, metric.NamespaceInfoID, source.DecodeNamespaceInfoResult)
}

func (c *collectorMetricsQuerier) QueryNamespaceUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.NamespaceUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryNetZoneGiB(start, end time.Time) *source.Future[source.NetZoneGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetZoneGiBID, source.DecodeNetZoneGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetZonePricePerGiB(start, end time.Time) *source.Future[source.NetZonePricePerGiBResult] {
	return queryCollector(c, start, end, metric.NetZonePricePerGiBID, source.DecodeNetZonePricePerGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetRegionGiB(start, end time.Time) *source.Future[source.NetRegionGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetRegionGiBID, source.DecodeNetRegionGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetRegionPricePerGiB(start, end time.Time) *source.Future[source.NetRegionPricePerGiBResult] {
	return queryCollector(c, start, end, metric.NetRegionPricePerGiBID, source.DecodeNetRegionPricePerGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetInternetGiB(start, end time.Time) *source.Future[source.NetInternetGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetInternetGiBID, source.DecodeNetInternetGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetInternetPricePerGiB(start, end time.Time) *source.Future[source.NetInternetPricePerGiBResult] {
	return queryCollector(c, start, end, metric.NetInternetPricePerGiBID, source.DecodeNetInternetPricePerGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetInternetServiceGiB(start, end time.Time) *source.Future[source.NetInternetServiceGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetInternetServiceGiBID, source.DecodeNetInternetServiceGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetNatGatewayPricePerGiB(start, end time.Time) *source.Future[source.NetNatGatewayPricePerGiBResult] {
	return queryCollector(c, start, end, metric.NetNatGatewayPricePerGiBID, source.DecodeNetNatGatewayPricePerGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetNatGatewayGiB(start, end time.Time) *source.Future[source.NetNatGatewayGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetNatGatewayGiBID, source.DecodeNetNatGatewayGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetTransferBytes(start, end time.Time) *source.Future[source.NetTransferBytesResult] {
	return queryCollector(c, start, end, metric.NetTransferBytesID, source.DecodeNetTransferBytesResult)
}

func (c *collectorMetricsQuerier) QueryNetZoneIngressGiB(start, end time.Time) *source.Future[source.NetZoneIngressGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetZoneIngressGiBID, source.DecodeNetZoneIngressGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetRegionIngressGiB(start, end time.Time) *source.Future[source.NetRegionIngressGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetRegionIngressGiBID, source.DecodeNetRegionIngressGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetInternetIngressGiB(start, end time.Time) *source.Future[source.NetInternetIngressGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetInternetIngressGiBID, source.DecodeNetInternetIngressGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetInternetServiceIngressGiB(start, end time.Time) *source.Future[source.NetInternetServiceIngressGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetInternetServiceIngressGiBID, source.DecodeNetInternetServiceIngressGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetNatGatewayIngressPricePerGiB(start, end time.Time) *source.Future[source.NetNatGatewayPricePerGiBResult] {
	return queryCollector(c, start, end, metric.NetNatGatewayIngressPricePerGiBID, source.DecodeNetNatGatewayPricePerGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetNatGatewayIngressGiB(start, end time.Time) *source.Future[source.NetNatGatewayIngressGiBResult] {
	return queryCollectorGiB(c, start, end, metric.NetNatGatewayIngressGiBID, source.DecodeNetNatGatewayIngressGiBResult)
}

func (c *collectorMetricsQuerier) QueryNetReceiveBytes(start, end time.Time) *source.Future[source.NetReceiveBytesResult] {
	return queryCollector(c, start, end, metric.NetReceiveBytesID, source.DecodeNetReceiveBytesResult)
}

func (c *collectorMetricsQuerier) QueryNamespaceAnnotations(start, end time.Time) *source.Future[source.NamespaceAnnotationsResult] {
	return queryCollector(c, start, end, metric.NamespaceAnnotationsID, source.DecodeNamespaceAnnotationsResult)
}

func (c *collectorMetricsQuerier) QueryPodAnnotations(start, end time.Time) *source.Future[source.PodAnnotationsResult] {
	return queryCollector(c, start, end, metric.PodAnnotationsID, source.DecodePodAnnotationsResult)
}

func (c *collectorMetricsQuerier) QueryNodeLabels(start, end time.Time) *source.Future[source.NodeLabelsResult] {
	return queryCollector(c, start, end, metric.NodeLabelsID, source.DecodeNodeLabelsResult)
}

func (c *collectorMetricsQuerier) QueryNamespaceLabels(start, end time.Time) *source.Future[source.NamespaceLabelsResult] {
	return queryCollector(c, start, end, metric.NamespaceLabelsID, source.DecodeNamespaceLabelsResult)
}

func (c *collectorMetricsQuerier) QueryPodLabels(start, end time.Time) *source.Future[source.PodLabelsResult] {
	return queryCollector(c, start, end, metric.PodLabelsID, source.DecodePodLabelsResult)
}

func (c *collectorMetricsQuerier) QueryServiceInfo(start, end time.Time) *source.Future[source.ServiceInfoResult] {
	return queryCollector(c, start, end, metric.ServiceInfoID, source.DecodeServiceInfoResult)
}

func (c *collectorMetricsQuerier) QueryServiceUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.ServiceUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryServiceSelectorLabels(start, end time.Time) *source.Future[source.ServiceLabelsResult] {
	return queryCollector(c, start, end, metric.ServiceLabelsID, source.DecodeServiceLabelsResult)
}

func (c *collectorMetricsQuerier) QueryDeploymentInfo(start, end time.Time) *source.Future[source.DeploymentInfoResult] {
	return queryCollector(c, start, end, metric.DeploymentInfoID, source.DecodeDeploymentInfoResult)
}

func (c *collectorMetricsQuerier) QueryDeploymentUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.DeploymentUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryDeploymentLabels(start, end time.Time) *source.Future[source.LabelsResult] {
	return queryCollector(c, start, end, metric.DeploymentLabelsID, source.DecodeLabelsResult)
}

func (c *collectorMetricsQuerier) QueryDeploymentAnnotations(start, end time.Time) *source.Future[source.AnnotationsResult] {
	return queryCollector(c, start, end, metric.DeploymentAnnotationsID, source.DecodeAnnotationsResult)
}

func (c *collectorMetricsQuerier) QueryDeploymentMatchLabels(start, end time.Time) *source.Future[source.DeploymentLabelsResult] {
	return queryCollector(c, start, end, metric.DeploymentMatchLabelsID, source.DecodeDeploymentLabelsResult)
}

func (c *collectorMetricsQuerier) QueryStatefulSetInfo(start, end time.Time) *source.Future[source.StatefulSetInfoResult] {
	return queryCollector(c, start, end, metric.StatefulSetInfoID, source.DecodeStatefulSetInfoResult)
}

func (c *collectorMetricsQuerier) QueryStatefulSetUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.StatefulSetUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryStatefulSetLabels(start, end time.Time) *source.Future[source.LabelsResult] {
	return queryCollector(c, start, end, metric.StatefulSetLabelsID, source.DecodeLabelsResult)
}

func (c *collectorMetricsQuerier) QueryStatefulSetAnnotations(start, end time.Time) *source.Future[source.AnnotationsResult] {
	return queryCollector(c, start, end, metric.StatefulSetAnnotationsID, source.DecodeAnnotationsResult)
}

func (c *collectorMetricsQuerier) QueryStatefulSetMatchLabels(start, end time.Time) *source.Future[source.StatefulSetLabelsResult] {
	return queryCollector(c, start, end, metric.StatefulSetMatchLabelsID, source.DecodeStatefulSetLabelsResult)
}

func (c *collectorMetricsQuerier) QueryDaemonSetInfo(start, end time.Time) *source.Future[source.DaemonSetInfoResult] {
	return queryCollector(c, start, end, metric.DaemonSetInfoID, source.DecodeDaemonSetInfoResult)
}

func (c *collectorMetricsQuerier) QueryDaemonSetUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.DaemonSetUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryDaemonSetLabels(start, end time.Time) *source.Future[source.LabelsResult] {
	return queryCollector(c, start, end, metric.DaemonSetLabelsID, source.DecodeLabelsResult)
}

func (c *collectorMetricsQuerier) QueryDaemonSetAnnotations(start, end time.Time) *source.Future[source.AnnotationsResult] {
	return queryCollector(c, start, end, metric.DaemonSetAnnotationsID, source.DecodeAnnotationsResult)
}

func (c *collectorMetricsQuerier) QueryJobInfo(start, end time.Time) *source.Future[source.JobInfoResult] {
	return queryCollector(c, start, end, metric.JobInfoID, source.DecodeJobInfoResult)
}

func (c *collectorMetricsQuerier) QueryJobUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.JobUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryJobLabels(start, end time.Time) *source.Future[source.LabelsResult] {
	return queryCollector(c, start, end, metric.JobLabelsID, source.DecodeLabelsResult)
}

func (c *collectorMetricsQuerier) QueryJobAnnotations(start, end time.Time) *source.Future[source.AnnotationsResult] {
	return queryCollector(c, start, end, metric.JobAnnotationsID, source.DecodeAnnotationsResult)
}

func (c *collectorMetricsQuerier) QueryCronJobInfo(start, end time.Time) *source.Future[source.CronJobInfoResult] {
	return queryCollector(c, start, end, metric.CronJobInfoID, source.DecodeCronJobInfoResult)
}

func (c *collectorMetricsQuerier) QueryCronJobUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.CronJobUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryCronJobLabels(start, end time.Time) *source.Future[source.LabelsResult] {
	return queryCollector(c, start, end, metric.CronJobLabelsID, source.DecodeLabelsResult)
}

func (c *collectorMetricsQuerier) QueryCronJobAnnotations(start, end time.Time) *source.Future[source.AnnotationsResult] {
	return queryCollector(c, start, end, metric.CronJobAnnotationsID, source.DecodeAnnotationsResult)
}

func (c *collectorMetricsQuerier) QueryReplicaSetInfo(start, end time.Time) *source.Future[source.ReplicaSetInfoResult] {
	return queryCollector(c, start, end, metric.ReplicaSetInfoID, source.DecodeReplicaSetInfoResult)
}

func (c *collectorMetricsQuerier) QueryReplicaSetUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.ReplicaSetUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryReplicaSetLabels(start, end time.Time) *source.Future[source.LabelsResult] {
	return queryCollector(c, start, end, metric.ReplicaSetLabelsID, source.DecodeLabelsResult)
}

func (c *collectorMetricsQuerier) QueryReplicaSetAnnotations(start, end time.Time) *source.Future[source.AnnotationsResult] {
	return queryCollector(c, start, end, metric.ReplicaSetAnnotationsID, source.DecodeAnnotationsResult)
}

func (c *collectorMetricsQuerier) QueryReplicaSetOwners(start, end time.Time) *source.Future[source.OwnerResult] {
	return queryCollector(c, start, end, metric.ReplicaSetOwnerID, source.DecodeOwnerResult)
}

func (c *collectorMetricsQuerier) QueryPodsWithDaemonSetOwner(start, end time.Time) *source.Future[source.PodsWithDaemonSetOwnerResult] {
	return queryCollector(c, start, end, metric.PodsWithDaemonSetOwnerID, source.DecodePodsWithDaemonSetOwnerResult)
}

func (c *collectorMetricsQuerier) QueryPodsWithJobOwner(start, end time.Time) *source.Future[source.PodsWithJobOwnerResult] {
	return queryCollector(c, start, end, metric.PodsWithJobOwnerID, source.DecodePodsWithJobOwnerResult)
}

func (c *collectorMetricsQuerier) QueryPodsWithReplicaSetOwner(start, end time.Time) *source.Future[source.PodsWithReplicaSetOwnerResult] {
	return queryCollector(c, start, end, metric.PodsWithReplicaSetOwnerID, source.DecodePodsWithReplicaSetOwnerResult)
}

func (c *collectorMetricsQuerier) QueryReplicaSetsWithoutOwners(start, end time.Time) *source.Future[source.ReplicaSetsWithoutOwnersResult] {
	return queryCollector(c, start, end, metric.ReplicaSetsWithoutOwnersID, source.DecodeReplicaSetsWithoutOwnersResult)
}

func (c *collectorMetricsQuerier) QueryReplicaSetsWithRollout(start, end time.Time) *source.Future[source.ReplicaSetsWithRolloutResult] {
	return queryCollector(c, start, end, metric.ReplicaSetsWithRolloutID, source.DecodeReplicaSetsWithRolloutResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaInfo(start, end time.Time) *source.Future[source.ResourceQuotaInfoResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaInfoID, source.DecodeResourceQuotaInfoResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaUptime(start, end time.Time) *source.Future[source.UptimeResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaUptimeID, source.DecodeUptimeResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaSpecCPURequestAverage(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaSpecCPURequestAverageID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaSpecCPURequestMax(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaSpecCPURequestMaxID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaSpecRAMRequestAverage(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaSpecRAMRequestAverageID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaSpecRAMRequestMax(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaSpecRAMRequestMaxID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaSpecCPULimitAverage(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaSpecCPULimitAverageID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaSpecCPULimitMax(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaSpecCPULimitMaxID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaSpecRAMLimitAverage(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaSpecRAMLimitAverageID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaSpecRAMLimitMax(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaSpecRAMLimitMaxID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaStatusUsedCPURequestAverage(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaStatusUsedCPURequestAverageID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaStatusUsedCPURequestMax(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaStatusUsedCPURequestMaxID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaStatusUsedRAMRequestAverage(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaStatusUsedRAMRequestAverageID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaStatusUsedRAMRequestMax(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaStatusUsedRAMRequestMaxID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaStatusUsedCPULimitAverage(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaStatusUsedCPULimitAverageID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaStatusUsedCPULimitMax(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaStatusUsedCPULimitMaxID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaStatusUsedRAMLimitAverage(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaStatusUsedRAMLimitAverageID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryResourceQuotaStatusUsedRAMLimitMax(start, end time.Time) *source.Future[source.ResourceResult] {
	return queryCollector(c, start, end, metric.ResourceQuotaStatusUsedRAMLimitMaxID, source.DecodeResourceResult)
}

func (c *collectorMetricsQuerier) QueryDataCoverage(limitDays int) (time.Time, time.Time, error) {
	return c.collectorProvider.GetDailyDataCoverage(limitDays)
}


// Inference cost methods - not supported by collector source (only available via Prometheus)
func (c *collectorMetricsQuerier) QueryInferencePromptTokens(start, end time.Time) *source.Future[source.InferenceTokensResult] {
	ch := make(source.QueryResultsChan, 1)
	ch <- &source.QueryResults{
		Query: "QueryInferencePromptTokens",
		Error: fmt.Errorf("inference metrics not supported by collector source"),
	}
	decoder := func(result *source.QueryResult) *source.InferenceTokensResult {
		return &source.InferenceTokensResult{Values: make(map[string]float64)}
	}
	return source.NewFuture(decoder, ch)
}

func (c *collectorMetricsQuerier) QueryInferenceGenerationTokens(start, end time.Time) *source.Future[source.InferenceTokensResult] {
	ch := make(source.QueryResultsChan, 1)
	ch <- &source.QueryResults{
		Query: "QueryInferenceGenerationTokens",
		Error: fmt.Errorf("inference metrics not supported by collector source"),
	}
	decoder := func(result *source.QueryResult) *source.InferenceTokensResult {
		return &source.InferenceTokensResult{Values: make(map[string]float64)}
	}
	return source.NewFuture(decoder, ch)
}

func (c *collectorMetricsQuerier) QueryInferenceInputProcessingTime(start, end time.Time) *source.Future[source.InferenceProcessingTimeResult] {
	ch := make(source.QueryResultsChan, 1)
	ch <- &source.QueryResults{
		Query: "QueryInferenceInputProcessingTime",
		Error: fmt.Errorf("inference metrics not supported by collector source"),
	}
	decoder := func(result *source.QueryResult) *source.InferenceProcessingTimeResult {
		return &source.InferenceProcessingTimeResult{Values: make(map[string]float64)}
	}
	return source.NewFuture(decoder, ch)
}

func (c *collectorMetricsQuerier) QueryInferenceOutputProcessingTime(start, end time.Time) *source.Future[source.InferenceProcessingTimeResult] {
	ch := make(source.QueryResultsChan, 1)
	ch <- &source.QueryResults{
		Query: "QueryInferenceOutputProcessingTime",
		Error: fmt.Errorf("inference metrics not supported by collector source"),
	}
	decoder := func(result *source.QueryResult) *source.InferenceProcessingTimeResult {
		return &source.InferenceProcessingTimeResult{Values: make(map[string]float64)}
	}
	return source.NewFuture(decoder, ch)
}

func (c *collectorMetricsQuerier) QueryInferenceCachedTokens(start, end time.Time) *source.Future[source.InferenceTokensResult] {
	ch := make(source.QueryResultsChan, 1)
	ch <- &source.QueryResults{
		Query: "QueryInferenceCachedTokens",
		Error: fmt.Errorf("inference metrics not supported by collector source"),
	}
	decoder := func(result *source.QueryResult) *source.InferenceTokensResult {
		return &source.InferenceTokensResult{Values: make(map[string]float64)}
	}
	return source.NewFuture(decoder, ch)
}

func (c *collectorMetricsQuerier) QueryInferenceCacheConfig(t time.Time) *source.Future[source.InferenceCacheConfigResult] {
	ch := make(source.QueryResultsChan, 1)
	ch <- &source.QueryResults{
		Query: "QueryInferenceCacheConfig",
		Error: fmt.Errorf("inference metrics not supported by collector source"),
	}
	decoder := func(result *source.QueryResult) *source.InferenceCacheConfigResult {
		return &source.InferenceCacheConfigResult{Configs: make(map[string]*source.InferenceCacheConfig)}
	}
	return source.NewFuture(decoder, ch)
}