Add instance type offering availability to metrics

pkg/providers/instancetype/instancetype.go

@@ -118,16 +118,15 @@ func (p *Provider) List(ctx context.Context, kc *corev1beta1.KubeletConfiguratio
 		return item.([]*cloudprovider.InstanceType), nil
 	}
 	result := lo.Map(instanceTypes, func(i *ec2.InstanceTypeInfo, _ int) *cloudprovider.InstanceType {
+		instanceTypeVCPU.With(prometheus.Labels{
+			instanceTypeLabel: *i.InstanceType,
+		}).Set(float64(aws.Int64Value(i.VCpuInfo.DefaultVCpus)))
+		instanceTypeMemory.With(prometheus.Labels{
+			instanceTypeLabel: *i.InstanceType,
+		}).Set(float64(aws.Int64Value(i.MemoryInfo.SizeInMiB) * 1024 * 1024))
+
 		return NewInstanceType(ctx, i, kc, p.region, nodeClass, p.createOfferings(ctx, i, instanceTypeOfferings[aws.StringValue(i.InstanceType)], zones, subnetZones))
 	})
-	for _, instanceType := range instanceTypes {
-		InstanceTypeVCPU.With(prometheus.Labels{
-			InstanceTypeLabel: *instanceType.InstanceType,
-		}).Set(float64(aws.Int64Value(instanceType.VCpuInfo.DefaultVCpus)))
-		InstanceTypeMemory.With(prometheus.Labels{
-			InstanceTypeLabel: *instanceType.InstanceType,
-		}).Set(float64(aws.Int64Value(instanceType.MemoryInfo.SizeInMiB) * 1024 * 1024))
-	}
 	p.cache.SetDefault(key, result)
 	return result, nil
 }
@@ -167,6 +166,16 @@ func (p *Provider) createOfferings(ctx context.Context, instanceType *ec2.Instan
 				Price:        price,
 				Available:    available,
 			})
+			instanceTypeOfferingAvailable.With(prometheus.Labels{
+				instanceTypeLabel: *instanceType.InstanceType,
+				capacityTypeLabel: capacityType,
+				zoneLabel:         zone,
+			}).Set(float64(lo.Ternary(available, 1, 0)))
+			instanceTypeOfferingPriceEstimate.With(prometheus.Labels{
+				instanceTypeLabel: *instanceType.InstanceType,
+				capacityTypeLabel: capacityType,
+				zoneLabel:         zone,
+			}).Set(price)
 		}
 	}
 	return offerings

pkg/providers/instancetype/metrics.go

@@ -23,34 +23,61 @@ import (
 
 const (
 	cloudProviderSubsystem = "cloudprovider"
+	instanceTypeLabel      = "instance_type"
+	capacityTypeLabel      = "capacity_type"
+	zoneLabel              = "zone"
 )
 
 var (
-	InstanceTypeLabel = "instance_type"
-
-	InstanceTypeVCPU = prometheus.NewGaugeVec(
+	instanceTypeVCPU = prometheus.NewGaugeVec(
 		prometheus.GaugeOpts{
 			Namespace: metrics.Namespace,
 			Subsystem: cloudProviderSubsystem,
 			Name:      "instance_type_cpu_cores",
 			Help:      "VCPUs cores for a given instance type.",
 		},
 		[]string{
-			InstanceTypeLabel,
-		})
-
-	InstanceTypeMemory = prometheus.NewGaugeVec(
+			instanceTypeLabel,
+		},
+	)
+	instanceTypeMemory = prometheus.NewGaugeVec(
 		prometheus.GaugeOpts{
 			Namespace: metrics.Namespace,
 			Subsystem: cloudProviderSubsystem,
 			Name:      "instance_type_memory_bytes",
 			Help:      "Memory, in bytes, for a given instance type.",
 		},
 		[]string{
-			InstanceTypeLabel,
+			instanceTypeLabel,
+		},
+	)
+	instanceTypeOfferingAvailable = prometheus.NewGaugeVec(
+		prometheus.GaugeOpts{
+			Namespace: metrics.Namespace,
+			Subsystem: cloudProviderSubsystem,
+			Name:      "instance_type_offering_available",
+			Help:      "Instance type offering availability, based on instance type, capacity type, and zone",
+		},
+		[]string{
+			instanceTypeLabel,
+			capacityTypeLabel,
+			zoneLabel,
+		},
+	)
+	instanceTypeOfferingPriceEstimate = prometheus.NewGaugeVec(
+		prometheus.GaugeOpts{
+			Namespace: metrics.Namespace,
+			Subsystem: cloudProviderSubsystem,
+			Name:      "instance_type_offering_price_estimate",
+			Help:      "Instance type offering estimated estimated hourly price used when making informed decisions on node cost calculation, based on instance type, capacity type, and zone.",
+		},
+		[]string{
+			instanceTypeLabel,
+			capacityTypeLabel,
+			zoneLabel,
 		})
 )
 
 func init() {
-	crmetrics.Registry.MustRegister(InstanceTypeVCPU, InstanceTypeMemory)
+	crmetrics.Registry.MustRegister(instanceTypeVCPU, instanceTypeMemory, instanceTypeOfferingAvailable, instanceTypeOfferingPriceEstimate)
 }

pkg/providers/instancetype/suite_test.go

@@ -743,12 +743,12 @@ var _ = Describe("InstanceTypes", func() {
 	})
 
 	It("should expose vcpu metrics for instance types", func() {
-		instanceInfo, err := awsEnv.InstanceTypesProvider.List(ctx, nodePool.Spec.Template.Spec.Kubelet, nodeClass)
+		instanceTypes, err := awsEnv.InstanceTypesProvider.List(ctx, nodePool.Spec.Template.Spec.Kubelet, nodeClass)
 		Expect(err).To(BeNil())
-		Expect(len(instanceInfo)).To(BeNumerically(">", 0))
-		for _, info := range instanceInfo {
+		Expect(len(instanceTypes)).To(BeNumerically(">", 0))
+		for _, it := range instanceTypes {
 			metric, ok := FindMetricWithLabelValues("karpenter_cloudprovider_instance_type_cpu_cores", map[string]string{
-				instancetype.InstanceTypeLabel: info.Name,
+				"instance_type": it.Name,
 			})
 			Expect(ok).To(BeTrue())
 			Expect(metric).To(Not(BeNil()))
@@ -757,19 +757,37 @@ var _ = Describe("InstanceTypes", func() {
 		}
 	})
 	It("should expose memory metrics for instance types", func() {
-		instanceInfo, err := awsEnv.InstanceTypesProvider.List(ctx, nodePool.Spec.Template.Spec.Kubelet, nodeClass)
+		instanceTypes, err := awsEnv.InstanceTypesProvider.List(ctx, nodePool.Spec.Template.Spec.Kubelet, nodeClass)
 		Expect(err).To(BeNil())
-		Expect(len(instanceInfo)).To(BeNumerically(">", 0))
-		for _, info := range instanceInfo {
+		Expect(len(instanceTypes)).To(BeNumerically(">", 0))
+		for _, it := range instanceTypes {
 			metric, ok := FindMetricWithLabelValues("karpenter_cloudprovider_instance_type_memory_bytes", map[string]string{
-				instancetype.InstanceTypeLabel: info.Name,
+				"instance_type": it.Name,
 			})
 			Expect(ok).To(BeTrue())
 			Expect(metric).To(Not(BeNil()))
 			value := metric.GetGauge().Value
 			Expect(aws.Float64Value(value)).To(BeNumerically(">", 0))
 		}
 	})
+	It("should expose availability metrics for instance types", func() {
+		instanceTypes, err := awsEnv.InstanceTypesProvider.List(ctx, nodePool.Spec.Template.Spec.Kubelet, nodeClass)
+		Expect(err).To(BeNil())
+		Expect(len(instanceTypes)).To(BeNumerically(">", 0))
+		for _, it := range instanceTypes {
+			for _, of := range it.Offerings {
+				metric, ok := FindMetricWithLabelValues("karpenter_cloudprovider_instance_type_offering_available", map[string]string{
+					"instance_type": it.Name,
+					"capacity_type": of.CapacityType,
+					"zone":          of.Zone,
+				})
+				Expect(ok).To(BeTrue())
+				Expect(metric).To(Not(BeNil()))
+				value := metric.GetGauge().Value
+				Expect(aws.Float64Value(value)).To(BeNumerically("==", lo.Ternary(of.Available, 1, 0)))
+			}
+		}
+	})
 	It("should launch instances in local zones", func() {
 		ExpectApplied(ctx, env.Client, nodePool, nodeClass)
 		pod := coretest.UnschedulablePod(coretest.PodOptions{

pkg/providers/pricing/pricing.go

@@ -33,7 +33,6 @@ import (
 	"github.com/aws/aws-sdk-go/service/ec2/ec2iface"
 	"github.com/aws/aws-sdk-go/service/pricing"
 	"github.com/aws/aws-sdk-go/service/pricing/pricingiface"
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/samber/lo"
 	"go.uber.org/multierr"
 	"knative.dev/pkg/logging"
@@ -204,14 +203,6 @@ func (p *Provider) UpdateOnDemandPricing(ctx context.Context) error {
 	}
 
 	p.onDemandPrices = lo.Assign(onDemandPrices, onDemandMetalPrices)
-	for instanceType, price := range p.onDemandPrices {
-		InstancePriceEstimate.With(prometheus.Labels{
-			InstanceTypeLabel: instanceType,
-			CapacityTypeLabel: ec2.UsageClassTypeOnDemand,
-			RegionLabel:       p.region,
-			TopologyLabel:     "",
-		}).Set(price)
-	}
 	if p.cm.HasChanged("on-demand-prices", p.onDemandPrices) {
 		logging.FromContext(ctx).With("instance-type-count", len(p.onDemandPrices)).Debugf("updated on-demand pricing")
 	}
@@ -341,12 +332,6 @@ func (p *Provider) UpdateSpotPricing(ctx context.Context) error {
 				prices[instanceType] = map[string]float64{}
 			}
 			prices[instanceType][az] = spotPrice
-			InstancePriceEstimate.With(prometheus.Labels{
-				InstanceTypeLabel: instanceType,
-				CapacityTypeLabel: ec2.UsageClassTypeSpot,
-				RegionLabel:       p.region,
-				TopologyLabel:     az,
-			}).Set(spotPrice)
 		}
 		return true
 	})

pkg/providers/pricing/suite_test.go

@@ -307,10 +307,10 @@ var _ = Describe("Pricing", func() {
 func getPricingEstimateMetricValue(instanceType string, capacityType string, zone string) float64 {
 	var value *float64
 	metric, ok := FindMetricWithLabelValues("karpenter_cloudprovider_instance_type_price_estimate", map[string]string{
-		pricing.InstanceTypeLabel: instanceType,
-		pricing.CapacityTypeLabel: capacityType,
-		pricing.RegionLabel:       fake.DefaultRegion,
-		pricing.TopologyLabel:     zone,
+		"instance_type": instanceType,
+		"capacity_type": capacityType,
+		"region":        fake.DefaultRegion,
+		"zone":          zone,
 	})
 	Expect(ok).To(BeTrue())
 	value = metric.GetGauge().Value

website/content/en/preview/reference/metrics.md

@@ -151,8 +151,11 @@ Current count of nodes in cluster state
 
 ## Cloudprovider Metrics
 
-### `karpenter_cloudprovider_instance_type_price_estimate`
-Estimated hourly price used when making informed decisions on node cost calculation. This is updated once on startup and then every 12 hours.
+### `karpenter_cloudprovider_instance_type_offering_price_estimate`
+Instance type offering estimated estimated hourly price used when making informed decisions on node cost calculation, based on instance type, capacity type, and zone.
+
+### `karpenter_cloudprovider_instance_type_offering_available`
+Instance type offering availability, based on instance type, capacity type, and zone
 
 ### `karpenter_cloudprovider_instance_type_memory_bytes`
 Memory, in bytes, for a given instance type.