Merge master and add services and deployments pods matching

cloud/awsprovider.go

@@ -204,7 +204,7 @@ var regionToBillingRegionCode = map[string]string{
 	"us-gov-west-1":  "UGW1",
 }
 
-func (aws *AWS) GetLocalStorageQuery() (string, error) {
+func (aws *AWS) GetLocalStorageQuery(offset string) (string, error) {
 	return "", nil
 }
 

cloud/azureprovider.go

@@ -582,6 +582,6 @@ func (az *Azure) PVPricing(PVKey) (*PV, error) {
 	return nil, nil
 }
 
-func (az *Azure) GetLocalStorageQuery() (string, error) {
+func (az *Azure) GetLocalStorageQuery(offset string) (string, error) {
 	return "", nil
 }

cloud/customprovider.go

@@ -38,7 +38,7 @@ type customProviderKey struct {
 	Labels         map[string]string
 }
 
-func (*CustomProvider) GetLocalStorageQuery() (string, error) {
+func (*CustomProvider) GetLocalStorageQuery(offset string) (string, error) {
 	return "", nil
 }
 

cloud/gcpprovider.go

@@ -79,9 +79,9 @@ func gcpAllocationToOutOfClusterAllocation(gcpAlloc gcpAllocation) *OutOfCluster
 	}
 }
 
-func (gcp *GCP) GetLocalStorageQuery() (string, error) {
+func (gcp *GCP) GetLocalStorageQuery(offset string) (string, error) {
 	localStorageCost := 0.04 // TODO: Set to the price for the appropriate storage class. It's not trivial to determine the local storage disk type
-	return fmt.Sprintf(`sum(sum(container_fs_limit_bytes{device!="tmpfs", id="/"}) by (instance) / 1024 / 1024 / 1024) * %f`, localStorageCost), nil
+	return fmt.Sprintf(`sum(sum(container_fs_limit_bytes{device!="tmpfs", id="/"} %s) by (instance, cluster_id)) by (cluster_id) / 1024 / 1024 / 1024 * %f`, offset, localStorageCost), nil
 }
 
 func (gcp *GCP) GetConfig() (*CustomPricing, error) {

cloud/provider.go

@@ -154,7 +154,7 @@ type Provider interface {
 	UpdateConfig(r io.Reader, updateType string) (*CustomPricing, error)
 	GetConfig() (*CustomPricing, error)
 	GetManagementPlatform() (string, error)
-	GetLocalStorageQuery() (string, error)
+	GetLocalStorageQuery(offset string) (string, error)
 	ExternalAllocations(string, string, string) ([]*OutOfClusterAllocation, error)
 }
 

costmodel/cluster.go

@@ -148,9 +148,17 @@ func ClusterCostsForAllClusters(cli prometheusClient.Client, cloud costAnalyzerC
 		offset = fmt.Sprintf("offset %s", offset)
 	}
 
+	localStorageQuery, err := cloud.GetLocalStorageQuery(offset)
+	if err != nil {
+		return nil, err
+	}
+	if localStorageQuery != "" {
+		localStorageQuery = fmt.Sprintf("+ %s", localStorageQuery)
+	}
+
 	qCores := fmt.Sprintf(queryClusterCores, windowString, offset, windowString, offset, windowString, offset)
 	qRAM := fmt.Sprintf(queryClusterRAM, windowString, offset, windowString, offset)
-	qStorage := fmt.Sprintf(queryStorage, windowString, offset, windowString, offset, "")
+	qStorage := fmt.Sprintf(queryStorage, windowString, offset, windowString, offset, localStorageQuery)
 
 	klog.V(4).Infof("Running query %s", qCores)
 	resultClusterCores, err := Query(cli, qCores)
@@ -209,7 +217,12 @@ func ClusterCostsForAllClusters(cli prometheusClient.Client, cloud costAnalyzerC
 // ClusterCosts gives the current full cluster costs averaged over a window of time.
 func ClusterCosts(cli prometheusClient.Client, cloud costAnalyzerCloud.Provider, windowString, offset string) (*Totals, error) {
 
-	localStorageQuery, err := cloud.GetLocalStorageQuery()
+	// turn offsets of the format "[0-9+]h" into the format "offset [0-9+]h" for use in query templatess
+	if offset != "" {
+		offset = fmt.Sprintf("offset %s", offset)
+	}
+
+	localStorageQuery, err := cloud.GetLocalStorageQuery(offset)
 	if err != nil {
 		return nil, err
 	}
@@ -217,11 +230,6 @@ func ClusterCosts(cli prometheusClient.Client, cloud costAnalyzerCloud.Provider,
 		localStorageQuery = fmt.Sprintf("+ %s", localStorageQuery)
 	}
 
-	// turn offsets of the format "[0-9+]h" into the format "offset [0-9+]h" for use in query templatess
-	if offset != "" {
-		offset = fmt.Sprintf("offset %s", offset)
-	}
-
 	qCores := fmt.Sprintf(queryClusterCores, windowString, offset, windowString, offset, windowString, offset)
 	qRAM := fmt.Sprintf(queryClusterRAM, windowString, offset, windowString, offset)
 	qStorage := fmt.Sprintf(queryStorage, windowString, offset, windowString, offset, localStorageQuery)
@@ -279,7 +287,7 @@ func ClusterCosts(cli prometheusClient.Client, cloud costAnalyzerCloud.Provider,
 // ClusterCostsOverTime gives the full cluster costs over time
 func ClusterCostsOverTime(cli prometheusClient.Client, cloud costAnalyzerCloud.Provider, startString, endString, windowString, offset string) (*Totals, error) {
 
-	localStorageQuery, err := cloud.GetLocalStorageQuery()
+	localStorageQuery, err := cloud.GetLocalStorageQuery(offset)
 	if err != nil {
 		return nil, err
 	}

costmodel/costmodel.go

@@ -150,9 +150,12 @@ const (
 						* 
 						on (persistentvolumeclaim, namespace, cluster_id) group_right(storageclass, volumename) 
 				sum(kube_persistentvolumeclaim_resource_requests_storage_bytes) by (persistentvolumeclaim, namespace, cluster_id)`
-	queryPVCAllocation        = `avg_over_time(pod_pvc_allocation[24h])`
-	queryPVHourlyCost         = `avg_over_time(pv_hourly_cost[24h])`
-	queryNSLabels             = `avg_over_time(kube_namespace_labels[24h])`
+	queryPVCAllocation        = `avg_over_time(pod_pvc_allocation[%s])`
+	queryPVHourlyCost         = `avg_over_time(pv_hourly_cost[%s])`
+	queryNSLabels             = `avg_over_time(kube_namespace_labels[%s])`
+	queryPodLabels            = `avg_over_time(kube_pod_labels[%s])`
+	queryDeploymentLabels     = `avg_over_time(deployment_match_labels[%s])`
+	queryServiceLabels        = `avg_over_time(service_selector_labels[%s])`
 	queryZoneNetworkUsage     = `sum(increase(kubecost_pod_network_egress_bytes_total{internet="false", sameZone="false", sameRegion="true"}[%s] %s)) by (namespace,pod_name,cluster_id) / 1024 / 1024 / 1024`
 	queryRegionNetworkUsage   = `sum(increase(kubecost_pod_network_egress_bytes_total{internet="false", sameZone="false", sameRegion="false"}[%s] %s)) by (namespace,pod_name,cluster_id) / 1024 / 1024 / 1024`
 	queryInternetNetworkUsage = `sum(increase(kubecost_pod_network_egress_bytes_total{internet="true"}[%s] %s)) by (namespace,pod_name,cluster_id) / 1024 / 1024 / 1024`
@@ -347,12 +350,12 @@ func (cm *CostModel) ComputeCostData(cli prometheusClient.Client, clientset kube
 	go func() {
 		defer wg.Done()
 
-		podDeploymentsMapping, k8sErr = getPodDeployments(cm.Cache, podlist)
+		podDeploymentsMapping, k8sErr = getPodDeployments(cm.Cache, podlist, clusterID)
 		if k8sErr != nil {
 			return
 		}
 
-		podServicesMapping, k8sErr = getPodServices(cm.Cache, podlist)
+		podServicesMapping, k8sErr = getPodServices(cm.Cache, podlist, clusterID)
 		if k8sErr != nil {
 			return
 		}
@@ -477,9 +480,12 @@ func (cm *CostModel) ComputeCostData(cli prometheusClient.Client, clientset kube
 			if _, ok := nodes[nodeName]; ok {
 				nodeData = nodes[nodeName]
 			}
+
+			nsKey := ns + "," + clusterID
+
 			var podDeployments []string
-			if _, ok := podDeploymentsMapping[ns]; ok {
-				if ds, ok := podDeploymentsMapping[ns][pod.GetObjectMeta().GetName()]; ok {
+			if _, ok := podDeploymentsMapping[nsKey]; ok {
+				if ds, ok := podDeploymentsMapping[nsKey][pod.GetObjectMeta().GetName()]; ok {
 					podDeployments = ds
 				} else {
 					podDeployments = []string{}
@@ -508,8 +514,8 @@ func (cm *CostModel) ComputeCostData(cli prometheusClient.Client, clientset kube
 			}
 
 			var podServices []string
-			if _, ok := podServicesMapping[ns]; ok {
-				if svcs, ok := podServicesMapping[ns][pod.GetObjectMeta().GetName()]; ok {
+			if _, ok := podServicesMapping[nsKey]; ok {
+				if svcs, ok := podServicesMapping[nsKey][pod.GetObjectMeta().GetName()]; ok {
 					podServices = svcs
 				} else {
 					podServices = []string{}
@@ -1082,25 +1088,25 @@ func getNodeCost(cache ClusterCache, cp costAnalyzerCloud.Provider) (map[string]
 	return nodes, nil
 }
 
-func getPodServices(cache ClusterCache, podList []*v1.Pod) (map[string]map[string][]string, error) {
+func getPodServices(cache ClusterCache, podList []*v1.Pod, clusterID string) (map[string]map[string][]string, error) {
 	servicesList := cache.GetAllServices()
 	podServicesMapping := make(map[string]map[string][]string)
 	for _, service := range servicesList {
 		namespace := service.GetObjectMeta().GetNamespace()
 		name := service.GetObjectMeta().GetName()
-
-		if _, ok := podServicesMapping[namespace]; !ok {
-			podServicesMapping[namespace] = make(map[string][]string)
+		key := namespace + "," + clusterID
+		if _, ok := podServicesMapping[key]; !ok {
+			podServicesMapping[key] = make(map[string][]string)
 		}
 		s := labels.Set(service.Spec.Selector).AsSelectorPreValidated()
 		for _, pod := range podList {
 			labelSet := labels.Set(pod.GetObjectMeta().GetLabels())
 			if s.Matches(labelSet) && pod.GetObjectMeta().GetNamespace() == namespace {
-				services, ok := podServicesMapping[namespace][pod.GetObjectMeta().GetName()]
+				services, ok := podServicesMapping[key][pod.GetObjectMeta().GetName()]
 				if ok {
-					podServicesMapping[namespace][pod.GetObjectMeta().GetName()] = append(services, name)
+					podServicesMapping[key][pod.GetObjectMeta().GetName()] = append(services, name)
 				} else {
-					podServicesMapping[namespace][pod.GetObjectMeta().GetName()] = []string{name}
+					podServicesMapping[key][pod.GetObjectMeta().GetName()] = []string{name}
 				}
 			}
 		}
@@ -1108,14 +1114,16 @@ func getPodServices(cache ClusterCache, podList []*v1.Pod) (map[string]map[strin
 	return podServicesMapping, nil
 }
 
-func getPodDeployments(cache ClusterCache, podList []*v1.Pod) (map[string]map[string][]string, error) {
+func getPodDeployments(cache ClusterCache, podList []*v1.Pod, clusterID string) (map[string]map[string][]string, error) {
 	deploymentsList := cache.GetAllDeployments()
 	podDeploymentsMapping := make(map[string]map[string][]string) // namespace: podName: [deploymentNames]
 	for _, deployment := range deploymentsList {
 		namespace := deployment.GetObjectMeta().GetNamespace()
 		name := deployment.GetObjectMeta().GetName()
-		if _, ok := podDeploymentsMapping[namespace]; !ok {
-			podDeploymentsMapping[namespace] = make(map[string][]string)
+
+		key := namespace + "," + clusterID
+		if _, ok := podDeploymentsMapping[key]; !ok {
+			podDeploymentsMapping[key] = make(map[string][]string)
 		}
 		s, err := metav1.LabelSelectorAsSelector(deployment.Spec.Selector)
 		if err != nil {
@@ -1124,18 +1132,102 @@ func getPodDeployments(cache ClusterCache, podList []*v1.Pod) (map[string]map[st
 		for _, pod := range podList {
 			labelSet := labels.Set(pod.GetObjectMeta().GetLabels())
 			if s.Matches(labelSet) && pod.GetObjectMeta().GetNamespace() == namespace {
-				deployments, ok := podDeploymentsMapping[namespace][pod.GetObjectMeta().GetName()]
+				deployments, ok := podDeploymentsMapping[key][pod.GetObjectMeta().GetName()]
+				if ok {
+					podDeploymentsMapping[key][pod.GetObjectMeta().GetName()] = append(deployments, name)
+				} else {
+					podDeploymentsMapping[key][pod.GetObjectMeta().GetName()] = []string{name}
+				}
+			}
+		}
+	}
+	return podDeploymentsMapping, nil
+}
+
+func getPodDeploymentsWithMetrics(deploymentLabels map[string]map[string]string, podLabels map[string]map[string]string) (map[string]map[string][]string, error) {
+	podDeploymentsMapping := make(map[string]map[string][]string)
+
+	for depKey, depLabels := range deploymentLabels {
+		kt, err := NewKeyTuple(depKey)
+		if err != nil {
+			continue
+		}
+
+		namespace := kt.Namespace
+		name := kt.Key
+		clusterID := kt.ClusterID
+
+		key := namespace + "," + clusterID
+		if _, ok := podDeploymentsMapping[key]; !ok {
+			podDeploymentsMapping[key] = make(map[string][]string)
+		}
+		s := labels.Set(depLabels).AsSelectorPreValidated()
+		for podKey, pLabels := range podLabels {
+			pkey, err := NewKeyTuple(podKey)
+			if err != nil {
+				continue
+			}
+			podNamespace := pkey.Namespace
+			podName := pkey.Key
+			podClusterID := pkey.ClusterID
+
+			labelSet := labels.Set(pLabels)
+			if s.Matches(labelSet) && podNamespace == namespace && podClusterID == clusterID {
+				deployments, ok := podDeploymentsMapping[key][podName]
 				if ok {
-					podDeploymentsMapping[namespace][pod.GetObjectMeta().GetName()] = append(deployments, name)
+					podDeploymentsMapping[key][podName] = append(deployments, name)
 				} else {
-					podDeploymentsMapping[namespace][pod.GetObjectMeta().GetName()] = []string{name}
+					podDeploymentsMapping[key][podName] = []string{name}
 				}
 			}
 		}
 	}
+
 	return podDeploymentsMapping, nil
 }
 
+func getPodServicesWithMetrics(serviceLabels map[string]map[string]string, podLabels map[string]map[string]string) (map[string]map[string][]string, error) {
+	podServicesMapping := make(map[string]map[string][]string)
+
+	for servKey, servLabels := range serviceLabels {
+		kt, err := NewKeyTuple(servKey)
+		if err != nil {
+			continue
+		}
+
+		namespace := kt.Namespace
+		name := kt.Key
+		clusterID := kt.ClusterID
+
+		key := namespace + "," + clusterID
+		if _, ok := podServicesMapping[key]; !ok {
+			podServicesMapping[key] = make(map[string][]string)
+		}
+		s := labels.Set(servLabels).AsSelectorPreValidated()
+
+		for podKey, pLabels := range podLabels {
+			pkey, err := NewKeyTuple(podKey)
+			if err != nil {
+				continue
+			}
+			podNamespace := pkey.Namespace
+			podName := pkey.Key
+			podClusterID := pkey.ClusterID
+
+			labelSet := labels.Set(pLabels)
+			if s.Matches(labelSet) && podNamespace == namespace && podClusterID == clusterID {
+				services, ok := podServicesMapping[key][podName]
+				if ok {
+					podServicesMapping[key][podName] = append(services, name)
+				} else {
+					podServicesMapping[key][podName] = []string{name}
+				}
+			}
+		}
+	}
+	return podServicesMapping, nil
+}
+
 func costDataPassesFilters(costs *CostData, namespace string, cluster string) bool {
 	passesNamespace := namespace == "" || costs.Namespace == namespace
 	passesCluster := cluster == "" || costs.ClusterID == cluster
@@ -1184,7 +1276,7 @@ func (cm *CostModel) ComputeCostDataRange(cli prometheusClient.Client, clientset
 	}
 
 	var wg sync.WaitGroup
-	wg.Add(14)
+	wg.Add(17)
 
 	var promErr error
 	var resultRAMRequests interface{}
@@ -1234,17 +1326,32 @@ func (cm *CostModel) ComputeCostDataRange(cli prometheusClient.Client, clientset
 	}()
 	var pvPodAllocationResults interface{}
 	go func() {
-		pvPodAllocationResults, promErr = Query(cli, queryPVCAllocation)
+		pvPodAllocationResults, promErr = QueryRange(cli, fmt.Sprintf(queryPVCAllocation, window), start, end, window)
 		defer wg.Done()
 	}()
 	var pvCostResults interface{}
 	go func() {
-		pvCostResults, promErr = Query(cli, queryPVHourlyCost)
+		pvCostResults, promErr = QueryRange(cli, fmt.Sprintf(queryPVHourlyCost, window), start, end, window)
 		defer wg.Done()
 	}()
 	var nsLabelsResults interface{}
 	go func() {
-		nsLabelsResults, promErr = Query(cli, queryNSLabels)
+		nsLabelsResults, promErr = QueryRange(cli, fmt.Sprintf(queryNSLabels, window), start, end, window)
+		defer wg.Done()
+	}()
+	var podLabelsResults interface{}
+	go func() {
+		podLabelsResults, promErr = QueryRange(cli, fmt.Sprintf(queryPodLabels, window), start, end, window)
+		defer wg.Done()
+	}()
+	var serviceLabelsResults interface{}
+	go func() {
+		serviceLabelsResults, promErr = QueryRange(cli, fmt.Sprintf(queryServiceLabels, window), start, end, window)
+		defer wg.Done()
+	}()
+	var deploymentLabelsResults interface{}
+	go func() {
+		deploymentLabelsResults, promErr = QueryRange(cli, fmt.Sprintf(queryDeploymentLabels, window), start, end, window)
 		defer wg.Done()
 	}()
 	var normalizationResults interface{}
@@ -1261,12 +1368,12 @@ func (cm *CostModel) ComputeCostDataRange(cli prometheusClient.Client, clientset
 	go func() {
 		defer wg.Done()
 
-		podDeploymentsMapping, k8sErr = getPodDeployments(cm.Cache, podlist)
+		podDeploymentsMapping, k8sErr = getPodDeployments(cm.Cache, podlist, clusterID)
 		if k8sErr != nil {
 			return
 		}
 
-		podServicesMapping, k8sErr = getPodServices(cm.Cache, podlist)
+		podServicesMapping, k8sErr = getPodServices(cm.Cache, podlist, clusterID)
 		if k8sErr != nil {
 			return
 		}
@@ -1308,12 +1415,12 @@ func (cm *CostModel) ComputeCostDataRange(cli prometheusClient.Client, clientset
 		}
 	}
 
-	pvCostMapping, err := getPVCostMetrics(pvCostResults, clusterID)
+	pvCostMapping, err := GetPVCostMetrics(pvCostResults, clusterID)
 	if err != nil {
 		klog.V(1).Infof("Unable to get PV Hourly Cost Data: %s", err.Error())
 	}
 
-	pvAllocationMapping, err := getPVAllocationMetrics(pvPodAllocationResults, clusterID)
+	pvAllocationMapping, err := GetPVAllocationMetrics(pvPodAllocationResults, clusterID)
 	if err != nil {
 		klog.V(1).Infof("Unable to get PV Allocation Cost Data: %s", err.Error())
 	}
@@ -1329,6 +1436,33 @@ func (cm *CostModel) ComputeCostDataRange(cli prometheusClient.Client, clientset
 		appendNamespaceLabels(namespaceLabelsMapping, nsLabels)
 	}
 
+	podLabels, err := GetPodLabelsMetrics(podLabelsResults)
+	if err != nil {
+		klog.V(1).Infof("Unable to get Pod Labels for Metrics: %s", err.Error())
+	}
+
+	serviceLabels, err := GetServiceSelectorLabelsMetrics(serviceLabelsResults)
+	if err != nil {
+		klog.V(1).Infof("Unable to get Service Selector Labels for Metrics: %s", err.Error())
+	}
+
+	deploymentLabels, err := GetDeploymentMatchLabelsMetrics(deploymentLabelsResults)
+	if err != nil {
+		klog.V(1).Infof("Unable to get Deployment Match Labels for Metrics: %s", err.Error())
+	}
+
+	podDeploymentsMetricsMapping, err := getPodDeploymentsWithMetrics(deploymentLabels, podLabels)
+	if err != nil {
+		klog.V(1).Infof("Unable to get match Deployment Labels Metrics to Pods: %s", err.Error())
+	}
+	appendLabelsList(podDeploymentsMapping, podDeploymentsMetricsMapping)
+
+	podServicesMetricsMapping, err := getPodServicesWithMetrics(serviceLabels, podLabels)
+	if err != nil {
+		klog.V(1).Infof("Unable to get match Service Labels Metrics to Pods: %s", err.Error())
+	}
+	appendLabelsList(podServicesMapping, podServicesMetricsMapping)
+
 	networkUsageMap, err := GetNetworkUsageData(resultNetZoneRequests, resultNetRegionRequests, resultNetInternetRequests, clusterID)
 	if err != nil {
 		klog.V(1).Infof("Unable to get Network Cost Data: %s", err.Error())
@@ -1563,18 +1697,49 @@ func (cm *CostModel) ComputeCostDataRange(cli prometheusClient.Client, clientset
 					missingNodes[c.NodeName] = node
 				}
 			}
-			namespacelabels, ok := namespaceLabelsMapping[c.Namespace+","+c.ClusterID]
+
+			nsKey := c.Namespace + "," + c.ClusterID
+			podKey := c.Namespace + "," + c.PodName + "," + c.ClusterID
+
+			namespaceLabels, ok := namespaceLabelsMapping[nsKey]
 			if !ok {
 				klog.V(3).Infof("Missing data for namespace %s", c.Namespace)
 			}
 
+			pLabels := podLabels[podKey]
+			if pLabels == nil {
+				pLabels = make(map[string]string)
+			}
+
+			for k, v := range namespaceLabels {
+				pLabels[k] = v
+			}
+
+			var podDeployments []string
+			if _, ok := podDeploymentsMapping[nsKey]; ok {
+				if ds, ok := podDeploymentsMapping[nsKey][c.PodName]; ok {
+					podDeployments = ds
+				} else {
+					podDeployments = []string{}
+				}
+			}
+
+			var podServices []string
+			if _, ok := podServicesMapping[nsKey]; ok {
+				if svcs, ok := podServicesMapping[nsKey][c.PodName]; ok {
+					podServices = svcs
+				} else {
+					podServices = []string{}
+				}
+			}
+
 			var podPVs []*PersistentVolumeClaimData
 			var podNetCosts []*Vector
 
 			// For PVC data, we'll need to find the claim mapping and cost data. Will need to append
 			// cost data since that was populated by cluster data previously. We do this with
 			// the pod_pvc_allocation metric
-			podPVData, ok := pvAllocationMapping[c.Namespace+","+c.PodName+","+c.ClusterID]
+			podPVData, ok := pvAllocationMapping[podKey]
 			if !ok {
 				klog.V(4).Infof("Failed to locate pv allocation mapping for missing pod.")
 			}
@@ -1582,7 +1747,7 @@ func (cm *CostModel) ComputeCostDataRange(cli prometheusClient.Client, clientset
 			// For network costs, we'll use existing map since it should still contain the
 			// correct data.
 			var podNetworkCosts []*Vector
-			if usage, ok := networkUsageMap[c.Namespace+","+c.PodName+","+c.ClusterID]; ok {
+			if usage, ok := networkUsageMap[podKey]; ok {
 				netCosts, err := GetNetworkCost(usage, cp)
 				if err != nil {
 					klog.V(3).Infof("Error pulling network costs: %s", err.Error())
@@ -1593,7 +1758,6 @@ func (cm *CostModel) ComputeCostDataRange(cli prometheusClient.Client, clientset
 
 			// Check to see if any other data has been recorded for this namespace, pod, clusterId
 			// Follow the pattern of only allowing claims data per pod
-			podKey := c.Namespace + "," + c.PodName + "," + c.ClusterID
 			if !otherClusterPVRecorded[podKey] {
 				otherClusterPVRecorded[podKey] = true
 
@@ -1607,13 +1771,15 @@ func (cm *CostModel) ComputeCostDataRange(cli prometheusClient.Client, clientset
 				NodeName:        c.NodeName,
 				NodeData:        node,
 				Namespace:       c.Namespace,
+				Services:        podServices,
+				Deployments:     podDeployments,
 				RAMReq:          RAMReqV,
 				RAMUsed:         RAMUsedV,
 				CPUReq:          CPUReqV,
 				CPUUsed:         CPUUsedV,
 				GPUReq:          GPUReqV,
-				Labels:          namespacelabels,
-				NamespaceLabels: namespacelabels,
+				Labels:          pLabels,
+				NamespaceLabels: namespaceLabels,
 				PVCData:         podPVs,
 				NetworkData:     podNetCosts,
 				ClusterID:       c.ClusterID,
@@ -1678,6 +1844,14 @@ func appendNamespaceLabels(nsLabels map[string]map[string]string, labels map[str
 	}
 }
 
+func appendLabelsList(mainLabels map[string]map[string][]string, labels map[string]map[string][]string) {
+	for k, v := range labels {
+		if _, ok := mainLabels[k]; !ok {
+			mainLabels[k] = v
+		}
+	}
+}
+
 func getNamespaceLabels(cache ClusterCache, clusterID string) (map[string]map[string]string, error) {
 	nsToLabels := make(map[string]map[string]string)
 	nss := cache.GetAllNamespaces()
@@ -2203,6 +2377,24 @@ func newContainerMetricFromPrometheus(metrics map[string]interface{}, defaultClu
 	}, nil
 }
 
+type KeyTuple struct {
+	Namespace string
+	Key       string
+	ClusterID string
+}
+
+func NewKeyTuple(key string) (*KeyTuple, error) {
+	r := strings.Split(key, ",")
+	if len(r) != 3 {
+		return nil, fmt.Errorf("NewKeyTuple() Provided key not containing exactly 3 components.")
+	}
+	return &KeyTuple{
+		Namespace: r[0],
+		Key:       r[1],
+		ClusterID: r[2],
+	}, nil
+}
+
 func GetContainerMetricVector(qr interface{}, normalize bool, normalizationValue float64, defaultClusterID string) (map[string][]*Vector, error) {
 	data, ok := qr.(map[string]interface{})["data"]
 	if !ok {

costmodel/promparsers.go

@@ -154,7 +154,7 @@ func parseDataPoint(dataPoint interface{}) (*Vector, error) {
 	}, nil
 }
 
-func getPVAllocationMetrics(queryResult interface{}, defaultClusterID string) (map[string][]*PersistentVolumeClaimData, error) {
+func GetPVAllocationMetrics(queryResult interface{}, defaultClusterID string) (map[string][]*PersistentVolumeClaimData, error) {
 	toReturn := make(map[string][]*PersistentVolumeClaimData)
 	result, err := NewQueryResults(queryResult)
 	if err != nil {
@@ -203,7 +203,7 @@ func getPVAllocationMetrics(queryResult interface{}, defaultClusterID string) (m
 	return toReturn, nil
 }
 
-func getPVCostMetrics(queryResult interface{}, defaultClusterID string) (map[string]*costAnalyzerCloud.PV, error) {
+func GetPVCostMetrics(queryResult interface{}, defaultClusterID string) (map[string]*costAnalyzerCloud.PV, error) {
 	toReturn := make(map[string]*costAnalyzerCloud.PV)
 	result, err := NewQueryResults(queryResult)
 	if err != nil {
@@ -256,6 +256,37 @@ func GetNamespaceLabelsMetrics(queryResult interface{}) (map[string]map[string]s
 	return toReturn, nil
 }
 
+func GetPodLabelsMetrics(queryResult interface{}) (map[string]map[string]string, error) {
+	toReturn := make(map[string]map[string]string)
+	result, err := NewQueryResults(queryResult)
+	if err != nil {
+		return toReturn, err
+	}
+
+	for _, val := range result {
+		// We want Pod, Namespace and ClusterID for key generation purposes
+		pod, err := val.GetString("pod")
+		if err != nil {
+			return toReturn, err
+		}
+
+		ns, err := val.GetString("namespace")
+		if err != nil {
+			return toReturn, err
+		}
+
+		clusterID, err := val.GetString("cluster_id")
+		if err != nil {
+			return toReturn, err
+		}
+
+		nsKey := ns + "," + pod + "," + clusterID
+		toReturn[nsKey] = val.GetLabels()
+	}
+
+	return toReturn, nil
+}
+
 func GetDeploymentMatchLabelsMetrics(queryResult interface{}) (map[string]map[string]string, error) {
 	toReturn := make(map[string]map[string]string)
 	result, err := NewQueryResults(queryResult)
@@ -295,7 +326,7 @@ func GetServiceSelectorLabelsMetrics(queryResult interface{}) (map[string]map[st
 	}
 
 	for _, val := range result {
-		// We want Namespace and ClusterID for key generation purposes
+		// We want Service, Namespace and ClusterID for key generation purposes
 		service, err := val.GetString("service")
 		if err != nil {
 			return toReturn, err