Logging, returning error when registration fails

core/pkg/model/kubemodel/namespace.go

@@ -3,6 +3,8 @@ package kubemodel
 import (
 	"fmt"
 	"time"
+
+	"github.com/opencost/opencost/core/pkg/log"
 )
 
 // @bingen:generate:Namespace
@@ -16,10 +18,11 @@ type Namespace struct {
 	End         time.Time         `json:"end"`         // @bingen:field[version=1]
 }
 
-func (kms *KubeModelSet) RegisterNamespace(uid, name string) {
+func (kms *KubeModelSet) RegisterNamespace(uid, name string) error {
 	if uid == "" {
-		kms.RegisterError(fmt.Sprintf("RegisterNamespace: uid is nil for Namespace '%s'", name))
-		return
+		err := fmt.Errorf("UID is nil for Namespace '%s'", name)
+		kms.RegisterError(err.Error())
+		return err
 	}
 
 	if _, ok := kms.Namespaces[uid]; !ok {
@@ -40,5 +43,10 @@ func (kms *KubeModelSet) RegisterNamespace(uid, name string) {
 		kms.idx.namespaceByName[name] = kms.Namespaces[uid]
 
 		kms.Metadata.ObjectCount++
+
+		// TODO remove or reduce log level
+		log.Infof("[KM] registered namespace (%s, %s)", uid, name)
 	}
+
+	return nil
 }

core/pkg/model/kubemodel/resourcequota.go

@@ -3,6 +3,8 @@ package kubemodel
 import (
 	"fmt"
 	"time"
+
+	"github.com/opencost/opencost/core/pkg/log"
 )
 
 // TODO: Do we need (Start, End) for these?
@@ -72,10 +74,11 @@ func (stat *ResourceQuotaStatusUsed) SetLimit(resource Resource, unit Unit, stat
 	stat.Limits.Set(resource, unit, statType, value)
 }
 
-func (kms *KubeModelSet) RegisterResourceQuota(uid, name, namespace string) {
+func (kms *KubeModelSet) RegisterResourceQuota(uid, name, namespace string) error {
 	if uid == "" {
-		kms.RegisterError(fmt.Sprintf("RegisterResourceQuota: uid is nil for ResourceQuota '%s'", name))
-		return
+		err := fmt.Errorf("UID is nil for ResourceQuota '%s'", name)
+		kms.RegisterError(err.Error())
+		return err
 	}
 
 	if _, ok := kms.ResourceQuotas[uid]; !ok {
@@ -96,5 +99,10 @@ func (kms *KubeModelSet) RegisterResourceQuota(uid, name, namespace string) {
 		}
 
 		kms.Metadata.ObjectCount++
+
+		// TODO remove or reduce log level
+		log.Infof("[KM] registered resource quota (%s, %s, %s)", uid, name, namespace)
 	}
+
+	return nil
 }

pkg/kubemodel/kubemodel.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/opencost/opencost/core/pkg/env"
+	"github.com/opencost/opencost/core/pkg/log"
 	"github.com/opencost/opencost/core/pkg/model/kubemodel"
 	"github.com/opencost/opencost/core/pkg/source"
 )
@@ -31,6 +32,9 @@ func NewKubeModel(dataSource source.OpenCostDataSource) (*KubeModel, error) {
 
 	km.clusterUID = clusterUID
 
+	// TODO reduce log level
+	log.Infof("[KM] NewKubeModel(%s)", km.clusterUID)
+
 	return km, nil
 }
 
@@ -38,6 +42,9 @@ func NewKubeModel(dataSource source.OpenCostDataSource) (*KubeModel, error) {
 // for the window defined by the given start and end times. The KubeModels
 // returned are unaggregated (i.e. down to the container level).
 func (km *KubeModel) ComputeKubeModelSet(start, end time.Time) (*kubemodel.KubeModelSet, error) {
+	// TODO reduce log level
+	log.Infof("[KM] ComputeKubeModel(%s, %s)", start.Format("2006-01-02 15:04:05"), end.Format("2006-01-02 15:04:05"))
+
 	// 1. Initialize new KubeModelSet for requested Window
 	kms := kubemodel.NewKubeModelSet(start, end)
 
@@ -103,12 +110,20 @@ func (km *KubeModel) computeNamespaces(kms *kubemodel.KubeModelSet, start, end t
 	nsAnnosResult, _ := nsAnnosResultFuture.Await()
 
 	for _, res := range nsLabelsResult {
-		kms.RegisterNamespace(res.UID, res.Namespace)
+		err := kms.RegisterNamespace(res.UID, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering namespace (%s, %s): %s", res.UID, res.Namespace, err)
+			continue
+		}
 		kms.Namespaces[res.UID].Labels = res.Labels
 	}
 
 	for _, res := range nsAnnosResult {
-		kms.RegisterNamespace(res.UID, res.Namespace)
+		err := kms.RegisterNamespace(res.UID, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering namespace (%s, %s): %s", res.UID, res.Namespace, err)
+			continue
+		}
 		kms.Namespaces[res.UID].Annotations = res.Annotations
 	}
 
@@ -151,105 +166,185 @@ func (km *KubeModel) computeResourceQuotas(kms *kubemodel.KubeModelSet, start, e
 
 	rqSpecCPURequestAverageResult, _ := rqSpecCPURequestAverageResultFuture.Await()
 	for _, res := range rqSpecCPURequestAverageResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		mcpu := uint64(res.Data[0].Value * 1000)
 		kms.ResourceQuotas[res.UID].Spec.Hard.SetRequest(kubemodel.ResourceCPU, kubemodel.UnitMillicore, kubemodel.StatAvg, mcpu)
 	}
 
 	rqSpecCPURequestMaxResult, _ := rqSpecCPURequestMaxResultFuture.Await()
 	for _, res := range rqSpecCPURequestMaxResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		mcpu := uint64(res.Data[0].Value * 1000)
 		kms.ResourceQuotas[res.UID].Spec.Hard.SetRequest(kubemodel.ResourceCPU, kubemodel.UnitMillicore, kubemodel.StatMax, mcpu)
 	}
 
 	rqSpecRAMRequestAverageResult, _ := rqSpecRAMRequestAverageResultFuture.Await()
 	for _, res := range rqSpecRAMRequestAverageResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		kms.ResourceQuotas[res.UID].Spec.Hard.SetRequest(kubemodel.ResourceMemory, kubemodel.UnitByte, kubemodel.StatAvg, uint64(res.Data[0].Value))
 	}
 
 	rqSpecRAMRequestMaxResult, _ := rqSpecRAMRequestMaxResultFuture.Await()
 	for _, res := range rqSpecRAMRequestMaxResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		kms.ResourceQuotas[res.UID].Spec.Hard.SetRequest(kubemodel.ResourceMemory, kubemodel.UnitByte, kubemodel.StatMax, uint64(res.Data[0].Value))
 	}
 
 	rqSpecCPULimitAverageResult, _ := rqSpecCPULimitAverageResultFuture.Await()
 	for _, res := range rqSpecCPULimitAverageResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		mcpu := uint64(res.Data[0].Value * 1000)
 		kms.ResourceQuotas[res.UID].Spec.Hard.SetLimit(kubemodel.ResourceCPU, kubemodel.UnitMillicore, kubemodel.StatAvg, mcpu)
 	}
 
 	rqSpecCPULimitMaxResult, _ := rqSpecCPULimitMaxResultFuture.Await()
 	for _, res := range rqSpecCPULimitMaxResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		mcpu := uint64(res.Data[0].Value * 1000)
 		kms.ResourceQuotas[res.UID].Spec.Hard.SetLimit(kubemodel.ResourceCPU, kubemodel.UnitMillicore, kubemodel.StatMax, mcpu)
 	}
 
 	rqSpecRAMLimitAverageResult, _ := rqSpecRAMLimitAverageResultFuture.Await()
 	for _, res := range rqSpecRAMLimitAverageResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		kms.ResourceQuotas[res.UID].Spec.Hard.SetLimit(kubemodel.ResourceMemory, kubemodel.UnitByte, kubemodel.StatAvg, uint64(res.Data[0].Value))
 	}
 
 	rqSpecRAMLimitMaxResult, _ := rqSpecRAMLimitMaxResultFuture.Await()
 	for _, res := range rqSpecRAMLimitMaxResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		kms.ResourceQuotas[res.UID].Spec.Hard.SetLimit(kubemodel.ResourceMemory, kubemodel.UnitByte, kubemodel.StatMax, uint64(res.Data[0].Value))
 	}
 
 	rqStatusUsedCPURequestAverageResult, _ := rqStatusUsedCPURequestAverageResultFuture.Await()
 	for _, res := range rqStatusUsedCPURequestAverageResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		mcpu := uint64(res.Data[0].Value * 1000)
 		kms.ResourceQuotas[res.UID].Status.Used.SetRequest(kubemodel.ResourceCPU, kubemodel.UnitMillicore, kubemodel.StatAvg, mcpu)
 	}
 
 	rqStatusUsedCPURequestMaxResult, _ := rqStatusUsedCPURequestMaxResultFuture.Await()
 	for _, res := range rqStatusUsedCPURequestMaxResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		mcpu := uint64(res.Data[0].Value * 1000)
 		kms.ResourceQuotas[res.UID].Status.Used.SetRequest(kubemodel.ResourceCPU, kubemodel.UnitMillicore, kubemodel.StatMax, mcpu)
 	}
 
 	rqStatusUsedRAMRequestAverageResult, _ := rqStatusUsedRAMRequestAverageResultFuture.Await()
 	for _, res := range rqStatusUsedRAMRequestAverageResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		kms.ResourceQuotas[res.UID].Status.Used.SetRequest(kubemodel.ResourceMemory, kubemodel.UnitByte, kubemodel.StatAvg, uint64(res.Data[0].Value))
 	}
 
 	rqStatusUsedRAMRequestMaxResult, _ := rqStatusUsedRAMRequestMaxResultFuture.Await()
 	for _, res := range rqStatusUsedRAMRequestMaxResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		kms.ResourceQuotas[res.UID].Status.Used.SetRequest(kubemodel.ResourceMemory, kubemodel.UnitByte, kubemodel.StatMax, uint64(res.Data[0].Value))
 	}
 
 	rqStatusUsedCPULimitAverageResult, _ := rqStatusUsedCPULimitAverageResultFuture.Await()
 	for _, res := range rqStatusUsedCPULimitAverageResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		mcpu := uint64(res.Data[0].Value * 1000)
 		kms.ResourceQuotas[res.UID].Status.Used.SetLimit(kubemodel.ResourceCPU, kubemodel.UnitMillicore, kubemodel.StatAvg, mcpu)
 	}
 
 	rqStatusUsedCPULimitMaxResult, _ := rqStatusUsedCPULimitMaxResultFuture.Await()
 	for _, res := range rqStatusUsedCPULimitMaxResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		mcpu := uint64(res.Data[0].Value * 1000)
 		kms.ResourceQuotas[res.UID].Status.Used.SetLimit(kubemodel.ResourceCPU, kubemodel.UnitMillicore, kubemodel.StatMax, mcpu)
 	}
 
 	rqStatusUsedRAMLimitAverageResult, _ := rqStatusUsedRAMLimitAverageResultFuture.Await()
 	for _, res := range rqStatusUsedRAMLimitAverageResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		kms.ResourceQuotas[res.UID].Status.Used.SetLimit(kubemodel.ResourceMemory, kubemodel.UnitByte, kubemodel.StatAvg, uint64(res.Data[0].Value))
 	}
 
 	rqStatusUsedRAMLimitMaxResult, _ := rqStatusUsedRAMLimitMaxResultFuture.Await()
 	for _, res := range rqStatusUsedRAMLimitMaxResult {
-		kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		err := kms.RegisterResourceQuota(res.UID, res.ResourceQuota, res.Namespace)
+		if err != nil {
+			log.Warnf("error registering resource quota (%s, %s, %s): %s", res.UID, res.ResourceQuota, res.Namespace, err)
+			continue
+		}
+
 		kms.ResourceQuotas[res.UID].Status.Used.SetLimit(kubemodel.ResourceMemory, kubemodel.UnitByte, kubemodel.StatMax, uint64(res.Data[0].Value))
 	}