add metrics for managed LBs

Author: oliviassss

Diff for: docs/install/iam_policy.json

@@ -42,7 +42,8 @@
                 "elasticloadbalancing:DescribeTags",
                 "elasticloadbalancing:DescribeTrustStores",
                 "elasticloadbalancing:DescribeListenerAttributes",
-                "elasticloadbalancing:DescribeCapacityReservation"
+                "elasticloadbalancing:DescribeCapacityReservation",
+                "tag: GetResources"
             ],
             "Resource": "*"
         },

Diff for: main.go

@@ -106,7 +106,14 @@ func main() {
 	}
 
 	// for open-source LBC, we track the resources with finalizers contains "k8s.aws"
-	lbcMetricsCollector := lbcmetrics.NewCollector(metrics.Registry, mgr.GetClient(), "k8s.aws")
+	lbcMetricsCollector := lbcmetrics.NewCollector(
+		metrics.Registry,
+		mgr.GetClient(),
+		cloud.RGT(),
+		"k8s.aws",
+		"elbv2.k8s.aws/cluster",
+		controllerCFG.ClusterName,
+	)
 
 	clientSet, err := kubernetes.NewForConfig(mgr.GetConfig())
 	if err != nil {
@@ -166,17 +173,25 @@ func main() {
 
 	// update the managed resource every 30s
 	go func() {
-		ticker := time.NewTicker(30 * time.Second) // Call every 30 seconds
+		ticker := time.NewTicker(30 * time.Second)
 		defer ticker.Stop()
 
 		for {
 			select {
 			case <-ticker.C:
-				// Update metrics
+				// Update managed resource metrics
 				err := lbcMetricsCollector.UpdateManagedK8sResourceMetrics(context.Background())
 				if err != nil {
 					setupLog.Error(err, "failed to update managed Kubernetes resource metrics")
 				}
+				err = lbcMetricsCollector.UpdateManagedALBMetrics(context.Background())
+				if err != nil {
+					setupLog.Error(err, "failed to update managed ALB metrics")
+				}
+				err = lbcMetricsCollector.UpdateManagedNLBMetrics(context.Background())
+				if err != nil {
+					setupLog.Error(err, "failed to update managed NLB metrics")
+				}
 			}
 		}
 	}()

Diff for: pkg/metrics/lbc/collector.go

@@ -2,31 +2,48 @@ package lbc
 
 import (
 	"context"
+	awssdk "github.com/aws/aws-sdk-go-v2/aws"
+	rgtsdk "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
+	rgttypes "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types"
 	"github.com/prometheus/client_golang/prometheus"
 	corev1 "k8s.io/api/core/v1"
 	networkingv1 "k8s.io/api/networking/v1"
 	elbv2api "sigs.k8s.io/aws-load-balancer-controller/apis/elbv2/v1beta1"
+	"sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services"
 	"strings"
 
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"time"
 )
 
-const networkLoadBalancerStr = "nlb"
+const (
+	networkLoadBalancerStr = "nlb"
+	resourceTypeALB        = "elasticloadbalancing:loadbalancer/app"
+	resourceTypeNLB        = "elasticloadbalancing:loadbalancer/net"
+)
 
 type MetricCollector interface {
 	// ObservePodReadinessGateReady this metric is useful to determine how fast pods are becoming ready in the load balancer.
 	// Due to some architectural constraints, we can only emit this metric for pods that are using readiness gates.
 	ObservePodReadinessGateReady(namespace string, tgbName string, duration time.Duration)
 
-	// UpdateMetrics fetches and updates all relevant metrics.
+	// UpdateManagedK8sResourceMetrics fetches and updates managed k8s resources metrics.
 	UpdateManagedK8sResourceMetrics(ctx context.Context) error
+
+	// UpdateManagedALBMetrics updates managed ALB count metrics
+	UpdateManagedALBMetrics(ctx context.Context) error
+
+	//UpdateManagedNLBMetrics updates managed NLB count metrics
+	UpdateManagedNLBMetrics(ctx context.Context) error
 }
 
 type collector struct {
 	instruments      *instruments
 	runtimeClient    client.Client
+	rgt              services.RGT
 	finalizerKeyWord string
+	clusterTagKey    string
+	clusterTagVal    string
 }
 
 type noOpCollector struct{}
@@ -38,7 +55,15 @@ func (n *noOpCollector) UpdateManagedK8sResourceMetrics(_ context.Context) error
 	return nil
 }
 
-func NewCollector(registerer prometheus.Registerer, runtimeClient client.Client, finalizerKeyWord string) MetricCollector {
+func (n *noOpCollector) UpdateManagedALBMetrics(_ context.Context) error {
+	return nil
+}
+
+func (n *noOpCollector) UpdateManagedNLBMetrics(_ context.Context) error {
+	return nil
+}
+
+func NewCollector(registerer prometheus.Registerer, runtimeClient client.Client, rgt services.RGT, finalizerKeyWord string, clusterTagKey string, clusterTagVal string) MetricCollector {
 	if registerer == nil || runtimeClient == nil {
 		return &noOpCollector{}
 	}
@@ -47,7 +72,10 @@ func NewCollector(registerer prometheus.Registerer, runtimeClient client.Client,
 	return &collector{
 		instruments:      instruments,
 		runtimeClient:    runtimeClient,
+		rgt:              rgt,
 		finalizerKeyWord: finalizerKeyWord,
+		clusterTagKey:    clusterTagKey,
+		clusterTagVal:    clusterTagVal,
 	}
 }
 
@@ -77,7 +105,7 @@ func (c *collector) UpdateManagedK8sResourceMetrics(ctx context.Context) error {
 			}
 		}
 	}
-	c.instruments.ingressCount.Set(float64(ingressCount))
+	c.instruments.managedIngressCount.Set(float64(ingressCount))
 
 	// Fetch service count
 	serviceList := &corev1.ServiceList{}
@@ -98,7 +126,7 @@ func (c *collector) UpdateManagedK8sResourceMetrics(ctx context.Context) error {
 			serviceCount++
 		}
 	}
-	c.instruments.serviceCount.Set(float64(serviceCount))
+	c.instruments.managedServiceCount.Set(float64(serviceCount))
 
 	// Fetch TargetGroupBinding count
 	tgbList := &elbv2api.TargetGroupBindingList{}
@@ -114,7 +142,42 @@ func (c *collector) UpdateManagedK8sResourceMetrics(ctx context.Context) error {
 			}
 		}
 	}
-	c.instruments.tgbCount.Set(float64(tgbCount))
+	c.instruments.managedTGBCount.Set(float64(tgbCount))
+
+	return nil
+}
+
+func (c *collector) UpdateManagedALBMetrics(ctx context.Context) error {
+	count, err := c.getManagedAWSResourceMetrics(ctx, resourceTypeALB)
+	if err != nil {
+		return err
+	}
+	c.instruments.managedALBCount.Set(float64(count))
+	return nil
+}
 
+func (c *collector) UpdateManagedNLBMetrics(ctx context.Context) error {
+	count, err := c.getManagedAWSResourceMetrics(ctx, resourceTypeNLB)
+	if err != nil {
+		return err
+	}
+	c.instruments.managedNLBCount.Set(float64(count))
 	return nil
 }
+
+func (c *collector) getManagedAWSResourceMetrics(ctx context.Context, resourceType string) (count int, err error) {
+	req := &rgtsdk.GetResourcesInput{
+		ResourceTypeFilters: []string{resourceType},
+		TagFilters: []rgttypes.TagFilter{
+			{
+				Key:    awssdk.String(c.clusterTagKey),
+				Values: []string{c.clusterTagVal},
+			},
+		},
+	}
+	resources, err := c.rgt.GetResourcesAsList(ctx, req)
+	if err != nil {
+		return 0, err
+	}
+	return len(resources), nil
+}

Diff for: pkg/metrics/lbc/instruments.go

@@ -21,9 +21,11 @@ const (
 
 type instruments struct {
 	podReadinessFlipSeconds *prometheus.HistogramVec
-	ingressCount            prometheus.Gauge
-	serviceCount            prometheus.Gauge
-	tgbCount                prometheus.Gauge
+	managedIngressCount     prometheus.Gauge
+	managedServiceCount     prometheus.Gauge
+	managedTGBCount         prometheus.Gauge
+	managedALBCount         prometheus.Gauge
+	managedNLBCount         prometheus.Gauge
 }
 
 // newInstruments allocates and register new metrics to registerer
@@ -34,28 +36,40 @@ func newInstruments(registerer prometheus.Registerer) *instruments {
 		Help:      "Latency from pod getting added to the load balancer until the readiness gate is flipped to healthy.",
 		Buckets:   []float64{10, 30, 60, 120, 180, 240, 300, 360, 420, 480, 540, 600},
 	}, []string{labelNamespace, labelName})
-	ingressCount := prometheus.NewGauge(prometheus.GaugeOpts{
+	managedIngressCount := prometheus.NewGauge(prometheus.GaugeOpts{
 		Name: "lb_controller_managed_ingress_count",
 		Help: "Number of ingresses managed by the AWS Load Balancer Controller.",
 	})
-	serviceCount := prometheus.NewGauge(prometheus.GaugeOpts{
+	managedServiceCount := prometheus.NewGauge(prometheus.GaugeOpts{
 		Name: "lb_controller_managed_service_count",
 		Help: "Number of service type Load Balancers (NLBs) managed by the AWS Load Balancer Controller.",
 	})
-	tgbCount := prometheus.NewGauge(prometheus.GaugeOpts{
+	managedTGBCount := prometheus.NewGauge(prometheus.GaugeOpts{
 		Name: "lb_controller_managed_targetgroupbinding_count",
 		Help: "Number of targetgroupbindings managed by the AWS Load Balancer Controller.",
 	})
+	managedALBCount := prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "lb_controller_managed_albs_total",
+		Help: "Current number of ALBs managed by the controller",
+	})
+	managedNLBCount := prometheus.NewGauge(prometheus.GaugeOpts{
+		Name: "lb_controller_managed_nlbs_total",
+		Help: "Current number of NLBs managed by the controller",
+	})
 	registerer.MustRegister(
 		podReadinessFlipSeconds,
-		ingressCount,
-		serviceCount,
-		tgbCount,
+		managedIngressCount,
+		managedServiceCount,
+		managedTGBCount,
+		managedALBCount,
+		managedNLBCount,
 	)
 	return &instruments{
 		podReadinessFlipSeconds: podReadinessFlipSeconds,
-		ingressCount:            ingressCount,
-		serviceCount:            serviceCount,
-		tgbCount:                tgbCount,
+		managedIngressCount:     managedIngressCount,
+		managedServiceCount:     managedServiceCount,
+		managedTGBCount:         managedTGBCount,
+		managedALBCount:         managedALBCount,
+		managedNLBCount:         managedNLBCount,
 	}
 }

Diff for: pkg/metrics/lbc/mockcollector.go

@@ -26,6 +26,18 @@ func (m *MockCollector) UpdateManagedK8sResourceMetrics(ctx context.Context) err
 	return nil // No-op for the mock
 }
 
+// UpdateManagedALBMetrics mocks updating managed ALB resource metrics.
+func (m *MockCollector) UpdateManagedALBMetrics(ctx context.Context) error {
+	m.recordInvocation("UpdateManagedALBMetrics", ctx)
+	return nil // No-op for the mock
+}
+
+// UpdateManagedNLBMetrics mocks updating managed ALB resource metrics.
+func (m *MockCollector) UpdateManagedNLBMetrics(ctx context.Context) error {
+	m.recordInvocation("UpdateManagedALBMetrics", ctx)
+	return nil // No-op for the mock
+}
+
 // recordHistogram adds a histogram metric invocation.
 func (m *MockCollector) recordHistogram(metricName string, namespace string, name string, d time.Duration) {
 	if _, exists := m.Invocations[metricName]; !exists {