feat: target group info metric

Author: msvticket

controllers/ingress/group_controller.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/go-logr/logr"
 	"github.com/pkg/errors"
+	"github.com/prometheus/client_golang/prometheus"
 	corev1 "k8s.io/api/core/v1"
 	networking "k8s.io/api/networking/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -43,11 +44,21 @@ const (
 )
 
 // NewGroupReconciler constructs new GroupReconciler
-func NewGroupReconciler(cloud aws.Cloud, k8sClient client.Client, eventRecorder record.EventRecorder,
-	finalizerManager k8s.FinalizerManager, networkingSGManager networkingpkg.SecurityGroupManager,
-	networkingSGReconciler networkingpkg.SecurityGroupReconciler, subnetsResolver networkingpkg.SubnetsResolver,
-	elbv2TaggingManager elbv2deploy.TaggingManager, controllerConfig config.ControllerConfig, backendSGProvider networkingpkg.BackendSGProvider,
-	sgResolver networkingpkg.SecurityGroupResolver, logger logr.Logger) *groupReconciler {
+func NewGroupReconciler(
+	cloud aws.Cloud,
+	k8sClient client.Client,
+	eventRecorder record.EventRecorder,
+	finalizerManager k8s.FinalizerManager,
+	networkingSGManager networkingpkg.SecurityGroupManager,
+	networkingSGReconciler networkingpkg.SecurityGroupReconciler,
+	subnetsResolver networkingpkg.SubnetsResolver,
+	elbv2TaggingManager elbv2deploy.TaggingManager,
+	targetGroupMetric *prometheus.GaugeVec,
+	controllerConfig config.ControllerConfig,
+	backendSGProvider networkingpkg.BackendSGProvider,
+	sgResolver networkingpkg.SecurityGroupResolver,
+	logger logr.Logger,
+) *groupReconciler {
 
 	annotationParser := annotations.NewSuffixAnnotationParser(annotations.AnnotationPrefixIngress)
 	authConfigBuilder := ingress.NewDefaultAuthConfigBuilder(annotationParser)
@@ -62,7 +73,7 @@ func NewGroupReconciler(cloud aws.Cloud, k8sClient client.Client, eventRecorder
 		controllerConfig.DefaultSSLPolicy, controllerConfig.DefaultTargetType, backendSGProvider, sgResolver,
 		controllerConfig.EnableBackendSecurityGroup, controllerConfig.DisableRestrictedSGRules, controllerConfig.FeatureGates.Enabled(config.EnableIPTargetType), logger)
 	stackMarshaller := deploy.NewDefaultStackMarshaller()
-	stackDeployer := deploy.NewDefaultStackDeployer(cloud, k8sClient, networkingSGManager, networkingSGReconciler, elbv2TaggingManager,
+	stackDeployer := deploy.NewDefaultStackDeployer(cloud, k8sClient, networkingSGManager, networkingSGReconciler, elbv2TaggingManager, targetGroupMetric,
 		controllerConfig, ingressTagPrefix, logger)
 	classLoader := ingress.NewDefaultClassLoader(k8sClient, true)
 	classAnnotationMatcher := ingress.NewDefaultClassAnnotationMatcher(controllerConfig.IngressConfig.IngressClass)

controllers/service/service_controller.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/go-logr/logr"
 	"github.com/pkg/errors"
+	"github.com/prometheus/client_golang/prometheus"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/tools/record"
@@ -35,11 +36,22 @@ const (
 	controllerName          = "service"
 )
 
-func NewServiceReconciler(cloud aws.Cloud, k8sClient client.Client, eventRecorder record.EventRecorder,
-	finalizerManager k8s.FinalizerManager, networkingSGManager networking.SecurityGroupManager,
-	networkingSGReconciler networking.SecurityGroupReconciler, subnetsResolver networking.SubnetsResolver,
-	vpcInfoProvider networking.VPCInfoProvider, elbv2TaggingManager elbv2deploy.TaggingManager, controllerConfig config.ControllerConfig,
-	backendSGProvider networking.BackendSGProvider, sgResolver networking.SecurityGroupResolver, logger logr.Logger) *serviceReconciler {
+func NewServiceReconciler(
+	cloud aws.Cloud,
+	k8sClient client.Client,
+	eventRecorder record.EventRecorder,
+	finalizerManager k8s.FinalizerManager,
+	networkingSGManager networking.SecurityGroupManager,
+	networkingSGReconciler networking.SecurityGroupReconciler,
+	subnetsResolver networking.SubnetsResolver,
+	vpcInfoProvider networking.VPCInfoProvider,
+	elbv2TaggingManager elbv2deploy.TaggingManager,
+	targetGroupMetric *prometheus.GaugeVec,
+	controllerConfig config.ControllerConfig,
+	backendSGProvider networking.BackendSGProvider,
+	sgResolver networking.SecurityGroupResolver,
+	logger logr.Logger,
+) *serviceReconciler {
 
 	annotationParser := annotations.NewSuffixAnnotationParser(serviceAnnotationPrefix)
 	trackingProvider := tracking.NewDefaultProvider(serviceTagPrefix, controllerConfig.ClusterName)
@@ -49,7 +61,7 @@ func NewServiceReconciler(cloud aws.Cloud, k8sClient client.Client, eventRecorde
 		controllerConfig.DefaultSSLPolicy, controllerConfig.DefaultTargetType, controllerConfig.FeatureGates.Enabled(config.EnableIPTargetType), serviceUtils,
 		backendSGProvider, sgResolver, controllerConfig.EnableBackendSecurityGroup, controllerConfig.DisableRestrictedSGRules)
 	stackMarshaller := deploy.NewDefaultStackMarshaller()
-	stackDeployer := deploy.NewDefaultStackDeployer(cloud, k8sClient, networkingSGManager, networkingSGReconciler, elbv2TaggingManager, controllerConfig, serviceTagPrefix, logger)
+	stackDeployer := deploy.NewDefaultStackDeployer(cloud, k8sClient, networkingSGManager, networkingSGReconciler, elbv2TaggingManager, targetGroupMetric, controllerConfig, serviceTagPrefix, logger)
 	return &serviceReconciler{
 		k8sClient:         k8sClient,
 		eventRecorder:     eventRecorder,

main.go

@@ -18,6 +18,8 @@ package main
 
 import (
 	"os"
+
+	"sigs.k8s.io/aws-load-balancer-controller/pkg/aws/metrics"
 	elbv2deploy "sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/elbv2"
 
 	"github.com/go-logr/logr"
@@ -46,7 +48,7 @@ import (
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/healthz"
 	"sigs.k8s.io/controller-runtime/pkg/log/zap"
-	"sigs.k8s.io/controller-runtime/pkg/metrics"
+	k8smetric "sigs.k8s.io/controller-runtime/pkg/metrics"
 	// +kubebuilder:scaffold:imports
 )
 
@@ -76,7 +78,7 @@ func main() {
 	}
 	ctrl.SetLogger(getLoggerWithLogLevel(controllerCFG.LogLevel))
 
-	cloud, err := aws.NewCloud(controllerCFG.AWSConfig, metrics.Registry)
+	cloud, err := aws.NewCloud(controllerCFG.AWSConfig, k8smetric.Registry)
 	if err != nil {
 		setupLog.Error(err, "unable to initialize AWS cloud")
 		os.Exit(1)
@@ -114,11 +116,15 @@ func main() {
 		cloud.VpcID(), cloud.EC2(), mgr.GetClient(), controllerCFG.DefaultTags, ctrl.Log.WithName("backend-sg-provider"))
 	sgResolver := networking.NewDefaultSecurityGroupResolver(cloud.EC2(), cloud.VpcID())
 	elbv2TaggingManager := elbv2deploy.NewDefaultTaggingManager(cloud.ELBV2(), cloud.VpcID(), controllerCFG.FeatureGates, cloud.RGT(), ctrl.Log)
+	targetGroupMetric, err := metrics.RegisterTargetGroupInfoMetric(k8smetric.Registry)
+	if err != nil {
+		setupLog.Error(err, "failed to register target binding information metric")
+	}
 	ingGroupReconciler := ingress.NewGroupReconciler(cloud, mgr.GetClient(), mgr.GetEventRecorderFor("ingress"),
-		finalizerManager, sgManager, sgReconciler, subnetResolver, elbv2TaggingManager,
+		finalizerManager, sgManager, sgReconciler, subnetResolver, elbv2TaggingManager, targetGroupMetric,
 		controllerCFG, backendSGProvider, sgResolver, ctrl.Log.WithName("controllers").WithName("ingress"))
 	svcReconciler := service.NewServiceReconciler(cloud, mgr.GetClient(), mgr.GetEventRecorderFor("service"),
-		finalizerManager, sgManager, sgReconciler, subnetResolver, vpcInfoProvider, elbv2TaggingManager,
+		finalizerManager, sgManager, sgReconciler, subnetResolver, vpcInfoProvider, elbv2TaggingManager, targetGroupMetric,
 		controllerCFG, backendSGProvider, sgResolver, ctrl.Log.WithName("controllers").WithName("service"))
 	tgbReconciler := elbv2controller.NewTargetGroupBindingReconciler(mgr.GetClient(), mgr.GetEventRecorderFor("targetGroupBinding"),
 		finalizerManager, tgbResManager,

pkg/aws/metrics/target_group.go

@@ -0,0 +1,40 @@
+package metrics
+
+import (
+	"strings"
+
+	"github.com/prometheus/client_golang/prometheus"
+	elbv2api "sigs.k8s.io/aws-load-balancer-controller/apis/elbv2/v1beta1"
+)
+
+const (
+	metricTargetGroupBinding = "target_group_info"
+
+	labelNamespace = "namespace"
+	// Name matches label when importing target group metrics using cloudwatch_exporter
+	labelTargetGroup = "target_group"
+)
+
+func RegisterTargetGroupInfoMetric(registerer prometheus.Registerer) (*prometheus.GaugeVec, error) {
+
+	targetGroupInfo := prometheus.NewGaugeVec(prometheus.GaugeOpts{
+		Subsystem: metricSubsystemAWS,
+		Name:      metricTargetGroupBinding,
+		Help:      "Information available about target group",
+	}, []string{labelNamespace, labelService, labelTargetGroup})
+
+	err := registerer.Register(targetGroupInfo)
+	return targetGroupInfo, err
+}
+
+func LabelsForTargetGroupBinding(resTGB *elbv2api.TargetGroupBinding) map[string]string {
+
+	// Extracting value of TargetGroup dimension in CloudWatch
+	// https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-cloudwatch-metrics.html#load-balancer-metric-dimensions-alb
+	targetGroup := resTGB.Spec.TargetGroupARN[strings.LastIndex(resTGB.Spec.TargetGroupARN, ":")+1:]
+	return map[string]string{
+		labelNamespace:   resTGB.Namespace,
+		labelService:     resTGB.Spec.ServiceRef.Name,
+		labelTargetGroup: targetGroup,
+	}
+}

pkg/deploy/elbv2/target_group_binding_manager.go

@@ -2,20 +2,23 @@ package elbv2
 
 import (
 	"context"
+	"time"
+
 	awssdk "github.com/aws/aws-sdk-go/aws"
 	"github.com/go-logr/logr"
 	"github.com/pkg/errors"
+	"github.com/prometheus/client_golang/prometheus"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/equality"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/wait"
 	elbv2api "sigs.k8s.io/aws-load-balancer-controller/apis/elbv2/v1beta1"
+	"sigs.k8s.io/aws-load-balancer-controller/pkg/aws/metrics"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/tracking"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/k8s"
 	elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	"time"
 )
 
 const (
@@ -35,11 +38,12 @@ type TargetGroupBindingManager interface {
 }
 
 // NewDefaultTargetGroupBindingManager constructs new defaultTargetGroupBindingManager
-func NewDefaultTargetGroupBindingManager(k8sClient client.Client, trackingProvider tracking.Provider, logger logr.Logger) *defaultTargetGroupBindingManager {
+func NewDefaultTargetGroupBindingManager(k8sClient client.Client, trackingProvider tracking.Provider, logger logr.Logger, metric *prometheus.GaugeVec) *defaultTargetGroupBindingManager {
 	return &defaultTargetGroupBindingManager{
-		k8sClient:        k8sClient,
-		trackingProvider: trackingProvider,
-		logger:           logger,
+		k8sClient:             k8sClient,
+		trackingProvider:      trackingProvider,
+		logger:                logger,
+		targetGroupInfoMetric: metric,
 
 		waitTGBObservedPollInterval: defaultWaitTGBObservedPollInterval,
 		waitTGBObservedTimout:       defaultWaitTGBObservedTimeout,
@@ -52,9 +56,10 @@ var _ TargetGroupBindingManager = &defaultTargetGroupBindingManager{}
 
 // default implementation for TargetGroupBindingManager.
 type defaultTargetGroupBindingManager struct {
-	k8sClient        client.Client
-	trackingProvider tracking.Provider
-	logger           logr.Logger
+	k8sClient             client.Client
+	trackingProvider      tracking.Provider
+	logger                logr.Logger
+	targetGroupInfoMetric *prometheus.GaugeVec
 
 	waitTGBObservedPollInterval time.Duration
 	waitTGBObservedTimout       time.Duration
@@ -88,6 +93,7 @@ func (m *defaultTargetGroupBindingManager) Create(ctx context.Context, resTGB *e
 		"stackID", resTGB.Stack().StackID(),
 		"resourceID", resTGB.ID(),
 		"targetGroupBinding", k8s.NamespacedName(k8sTGB))
+	m.targetGroupInfoMetric.With(metrics.LabelsForTargetGroupBinding(k8sTGB)).Set(1)
 	return buildResTargetGroupBindingStatus(k8sTGB), nil
 }
 
@@ -96,6 +102,7 @@ func (m *defaultTargetGroupBindingManager) Update(ctx context.Context, resTGB *e
 	if err != nil {
 		return elbv2model.TargetGroupBindingResourceStatus{}, err
 	}
+	m.targetGroupInfoMetric.With(metrics.LabelsForTargetGroupBinding(k8sTGB)).Set(1)
 	if equality.Semantic.DeepEqual(k8sTGB.Spec, k8sTGBSpec) {
 		return buildResTargetGroupBindingStatus(k8sTGB), nil
 	}
@@ -130,6 +137,7 @@ func (m *defaultTargetGroupBindingManager) Delete(ctx context.Context, tgb *elbv
 	}
 	m.logger.Info("deleted targetGroupBinding",
 		"targetGroupBinding", k8s.NamespacedName(tgb))
+	m.targetGroupInfoMetric.Delete(metrics.LabelsForTargetGroupBinding(tgb))
 	return nil
 }
 

pkg/deploy/stack_deployer.go

@@ -2,7 +2,9 @@ package deploy
 
 import (
 	"context"
+
 	"github.com/go-logr/logr"
+	"github.com/prometheus/client_golang/prometheus"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/aws"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/config"
 	"sigs.k8s.io/aws-load-balancer-controller/pkg/deploy/ec2"
@@ -23,10 +25,17 @@ type StackDeployer interface {
 }
 
 // NewDefaultStackDeployer constructs new defaultStackDeployer.
-func NewDefaultStackDeployer(cloud aws.Cloud, k8sClient client.Client,
-	networkingSGManager networking.SecurityGroupManager, networkingSGReconciler networking.SecurityGroupReconciler,
+func NewDefaultStackDeployer(
+	cloud aws.Cloud,
+	k8sClient client.Client,
+	networkingSGManager networking.SecurityGroupManager,
+	networkingSGReconciler networking.SecurityGroupReconciler,
 	elbv2TaggingManager elbv2.TaggingManager,
-	config config.ControllerConfig, tagPrefix string, logger logr.Logger) *defaultStackDeployer {
+	targetGroupMetric *prometheus.GaugeVec,
+	config config.ControllerConfig,
+	tagPrefix string,
+	logger logr.Logger,
+) *defaultStackDeployer {
 
 	trackingProvider := tracking.NewDefaultProvider(tagPrefix, config.ClusterName)
 	ec2TaggingManager := ec2.NewDefaultTaggingManager(cloud.EC2(), networkingSGManager, cloud.VpcID(), logger)
@@ -43,7 +52,7 @@ func NewDefaultStackDeployer(cloud aws.Cloud, k8sClient client.Client,
 		elbv2LSManager:                      elbv2.NewDefaultListenerManager(cloud.ELBV2(), trackingProvider, elbv2TaggingManager, config.ExternalManagedTags, config.FeatureGates, logger),
 		elbv2LRManager:                      elbv2.NewDefaultListenerRuleManager(cloud.ELBV2(), trackingProvider, elbv2TaggingManager, config.ExternalManagedTags, config.FeatureGates, logger),
 		elbv2TGManager:                      elbv2.NewDefaultTargetGroupManager(cloud.ELBV2(), trackingProvider, elbv2TaggingManager, cloud.VpcID(), config.ExternalManagedTags, logger),
-		elbv2TGBManager:                     elbv2.NewDefaultTargetGroupBindingManager(k8sClient, trackingProvider, logger),
+		elbv2TGBManager:                     elbv2.NewDefaultTargetGroupBindingManager(k8sClient, trackingProvider, logger, targetGroupMetric),
 		wafv2WebACLAssociationManager:       wafv2.NewDefaultWebACLAssociationManager(cloud.WAFv2(), logger),
 		wafRegionalWebACLAssociationManager: wafregional.NewDefaultWebACLAssociationManager(cloud.WAFRegional(), logger),
 		shieldProtectionManager:             shield.NewDefaultProtectionManager(cloud.Shield(), logger),