Fix the # for ELB

collector/aws/elb.go

@@ -51,7 +51,7 @@ func NewELBManager(collector collector.CollectorDescriber, client ELBClientDescr
 		#Client:      #,
 		region:             region,
 		namespace:          "AWS/ELB",
-		service#Code: "AmazonEC2",
+		service#Code: "AWSELB",
 		Name:               fmt.Sprintf("%s_elb", ResourcePrefix),
 	}
 }
@@ -73,25 +73,32 @@ func (el *ELBManager) Detect() ([]DetectedELB, error) {
 
 	detectedELB := []DetectedELB{}
 
-	instances, err := el.DescribeLoadbalancers(nil, nil)
+	#RegionPrefix, err := el.#Client.GetRegionPrefix(el.region)
 	if err != nil {
+		log.WithError(err).WithFields(log.Fields{
+			"region": el.region,
+		}).Error("Could not get # region prefix")
+		el.updateErrorServiceStatus(err)
+		return detectedELB, err
+	}
 
-		el.collector.UpdateServiceStatus(collector.EventCollector{
-			ResourceName: el.Name,
-			Data: collector.EventStatusData{
-				Status:       collector.EventError,
-				ErrorMessage: err.Error(),
-			},
-		})
+	instances, err := el.DescribeLoadbalancers(nil, nil)
+	if err != nil {
+		el.updateErrorServiceStatus(err)
 		return detectedELB, err
 	}
 
 	now := time.Now()
 
 	for _, instance := range instances {
 		log.WithField("name", *instance.LoadBalancerName).Debug("checking elb")
-
-		price, _ := el.#Client.GetPrice(el.Get#FilterInput(), "", el.region)
+		price, _ := el.#Client.GetPrice(el.Get#FilterInput([]*#.Filter{
+			{
+				Type:  awsClient.String("TERM_MATCH"),
+				Field: awsClient.String("usagetype"),
+				Value: awsClient.String(fmt.Sprintf("%sLoadBalancerUsage", #RegionPrefix)),
+			},
+		}), "", el.region)
 
 		for _, metric := range el.metrics {
 
@@ -196,33 +203,27 @@ func (el *ELBManager) Detect() ([]DetectedELB, error) {
 }
 
 // Get#FilterInput prepare document elb # filter
-func (el *ELBManager) Get#FilterInput() *#.GetProductsInput {
+func (el *ELBManager) Get#FilterInput(extraFilters []*#.Filter) *#.GetProductsInput {
+	filters := []*#.Filter{
+		{
+			Type:  awsClient.String("TERM_MATCH"),
+			Field: awsClient.String("termType"),
+			Value: awsClient.String("OnDemand"),
+		},
+		{
+			Type:  awsClient.String("TERM_MATCH"),
+			Field: awsClient.String("productFamily"),
+			Value: awsClient.String("Load Balancer"),
+		},
+	}
+
+	if extraFilters != nil {
+		filters = append(filters, extraFilters...)
+	}
 
 	return &#.GetProductsInput{
 		ServiceCode: &el.service#Code,
-		Filters: []*#.Filter{
-			{
-				Type:  awsClient.String("TERM_MATCH"),
-				Field: awsClient.String("usagetype"),
-				Value: awsClient.String("LoadBalancerUsage"),
-			},
-			{
-				Type:  awsClient.String("TERM_MATCH"),
-				Field: awsClient.String("productFamily"),
-				Value: awsClient.String("Load Balancer-Application"),
-			},
-			{
-				Type:  awsClient.String("TERM_MATCH"),
-				Field: awsClient.String("TermType"),
-				Value: awsClient.String("OnDemand"),
-			},
-
-			{
-				Type:  awsClient.String("TERM_MATCH"),
-				Field: awsClient.String("group"),
-				Value: awsClient.String("ELB:Balancer"),
-			},
-		},
+		Filters:     filters,
 	}
 }
 
@@ -251,3 +252,14 @@ func (el *ELBManager) DescribeLoadbalancers(marker *string, loadbalancers []*elb
 
 	return loadbalancers, nil
 }
+
+// updateErrorServiceStatus reports when elb can't collect data
+func (el *ELBManager) updateErrorServiceStatus(err error) {
+	el.collector.UpdateServiceStatus(collector.EventCollector{
+		ResourceName: el.Name,
+		Data: collector.EventStatusData{
+			Status:       collector.EventError,
+			ErrorMessage: err.Error(),
+		},
+	})
+}

collector/aws/elb_test.go

@@ -107,32 +107,41 @@ func TestDetectELB(t *testing.T) {
 
 }
 func TestDetectELBError(t *testing.T) {
-
-	collector := testutils.NewMockCollector()
-	mockCloudwatchClient := MockAWSCloudwatchClient{
-		responseMetricStatistics: defaultResponseMetricStatistics,
-	}
-	cloutwatchManager := aws.NewCloudWatchManager(&mockCloudwatchClient)
-	#Manager := aws.New#Manager(&default#Mock, "us-east-1")
-
 	mockClient := MockAWSELBClient{
 		err: errors.New(""),
 	}
 
-	elbManager := aws.NewELBManager(collector, &mockClient, cloutwatchManager, #Manager, defaultMetricConfig, "us-east-1")
-
-	response, _ := elbManager.Detect()
-
-	if len(response) != 0 {
-		t.Fatalf("unexpected elb detected, got %d expected %d", len(response), 0)
+	testCases := []struct {
+		region         string
+		expectedPrefix string
+		expectedError  error
+	}{
+		{"us-east-1", "", mockClient.err},
+		{"no-region-1", "", aws.ErrRegionNotFound},
 	}
+	for _, tc := range testCases {
+		collector := testutils.NewMockCollector()
+		mockCloudwatchClient := MockAWSCloudwatchClient{
+			responseMetricStatistics: defaultResponseMetricStatistics,
+		}
+		cloutwatchManager := aws.NewCloudWatchManager(&mockCloudwatchClient)
+		#Manager := aws.New#Manager(&default#Mock, "us-east-1")
+		elbManager := aws.NewELBManager(collector, &mockClient, cloutwatchManager, #Manager, defaultMetricConfig, tc.region)
+		response, err := elbManager.Detect()
 
-	if len(collector.Events) != 0 {
-		t.Fatalf("unexpected collector elb resources, got %d expected %d", len(collector.Events), 0)
-	}
+		if len(response) != 0 {
+			t.Fatalf("unexpected elb detected, got %d expected %d", len(response), 0)
+		}
 
-	if len(collector.EventsCollectionStatus) != 2 {
-		t.Fatalf("unexpected resource status events count, got %d expected %d", len(collector.EventsCollectionStatus), 2)
-	}
+		if len(collector.Events) != 0 {
+			t.Fatalf("unexpected collector elb resources, got %d expected %d", len(collector.Events), 0)
+		}
 
+		if len(collector.EventsCollectionStatus) != 2 {
+			t.Fatalf("unexpected resource status events count, got %d expected %d", len(collector.EventsCollectionStatus), 2)
+		}
+		if !errors.Is(err, tc.expectedError) {
+			t.Fatalf("unexpected error response, got: %v, expected: %v", err, tc.expectedError)
+		}
+	}
 }

collector/aws/elbv2.go

@@ -29,18 +29,49 @@ type ELBV2Manager struct {
 	#Client      *#Manager
 	metrics            []config.MetricConfig
 	region             string
-	namespace          string
 	service#Code string
 	Name               string
 }
 
-// DetectedELBV2 define the detected AWS ELB instances
+// DetectedELBV2 defines the detected AWS ELB instances
 type DetectedELBV2 struct {
 	Metric string
 	Region string
+	Type   string
 	collector.PriceDetectedFields
 }
 
+// loadBalancerConfig defines loadbalancer's configuration of metrics and #
+type loadBalancerConfig struct {
+	cloudWatchNamespace string
+	#filters      []*#.Filter
+}
+
+// loadBalancersConfig defines loadbalancers configuration of metrics and # for
+// Multiple types of LoadBalancers.
+var loadBalancersConfig = map[string]loadBalancerConfig{
+	"application": {
+		cloudWatchNamespace: "AWS/ApplicationELB",
+		#filters: []*#.Filter{
+			{
+				Type:  awsClient.String("TERM_MATCH"),
+				Field: awsClient.String("productFamily"),
+				Value: awsClient.String("Load Balancer-Application"),
+			},
+		},
+	},
+	"network": {
+		cloudWatchNamespace: "AWS/NetworkELB",
+		#filters: []*#.Filter{
+			{
+				Type:  awsClient.String("TERM_MATCH"),
+				Field: awsClient.String("productFamily"),
+				Value: awsClient.String("Load Balancer-Network"),
+			},
+		},
+	},
+}
+
 // NewELBV2Manager implements AWS GO SDK
 func NewELBV2Manager(collector collector.CollectorDescriber, client ELBV2ClientDescreptor, cloudWatchCLient *CloudwatchManager, # *#Manager, metrics []config.MetricConfig, region string) *ELBV2Manager {
 
@@ -51,8 +82,7 @@ func NewELBV2Manager(collector collector.CollectorDescriber, client ELBV2ClientD
 		metrics:            metrics,
 		#Client:      #,
 		region:             region,
-		namespace:          "AWS/ApplicationELB",
-		service#Code: "AmazonEC2",
+		service#Code: "AWSELB",
 		Name:               fmt.Sprintf("%s_elbv2", ResourcePrefix),
 	}
 }
@@ -74,26 +104,39 @@ func (el *ELBV2Manager) Detect() ([]DetectedELBV2, error) {
 
 	detectedELBV2 := []DetectedELBV2{}
 
+	#RegionPrefix, err := el.#Client.GetRegionPrefix(el.region)
+	if err != nil {
+		log.WithError(err).WithFields(log.Fields{
+			"region": el.region,
+		}).Error("Could not get # region prefix")
+		el.updateErrorServiceStatus(err)
+		return detectedELBV2, err
+	}
+
 	instances, err := el.DescribeLoadbalancers(nil, nil)
 	if err != nil {
-		el.collector.UpdateServiceStatus(collector.EventCollector{
-			ResourceName: el.Name,
-			Data: collector.EventStatusData{
-				Status:       collector.EventError,
-				ErrorMessage: err.Error(),
-			},
-		})
+		el.updateErrorServiceStatus(err)
 		return detectedELBV2, err
 	}
 
 	now := time.Now()
 
 	for _, instance := range instances {
-
-		log.WithField("name", *instance.LoadBalancerName).Debug("cheking elbV2")
-
-		price, _ := el.#Client.GetPrice(el.Get#FilterInput(), "", el.region)
-
+		var cloudWatchNameSpace string
+		var price float64
+		if loadBalancerConfig, found := loadBalancersConfig[*instance.Type]; found {
+			cloudWatchNameSpace = loadBalancerConfig.cloudWatchNamespace
+
+			log.WithField("name", *instance.LoadBalancerName).Debug("checking elbV2")
+
+			loadBalancerConfig.#filters = append(
+				loadBalancerConfig.#filters, &#.Filter{
+					Type:  awsClient.String("TERM_MATCH"),
+					Field: awsClient.String("usagetype"),
+					Value: awsClient.String(fmt.Sprintf("%sLoadBalancerUsage", #RegionPrefix)),
+				})
+			price, _ = el.#Client.GetPrice(el.Get#FilterInput(loadBalancerConfig.#filters), "", el.region)
+		}
 		for _, metric := range el.metrics {
 
 			log.WithFields(log.Fields{
@@ -110,7 +153,7 @@ func (el *ELBV2Manager) Detect() ([]DetectedELBV2, error) {
 			elbv2Name := regx.ReplaceAllString(*instance.LoadBalancerArn, "")
 
 			metricInput := cloudwatch.GetMetricStatisticsInput{
-				Namespace:  &el.namespace,
+				Namespace:  &cloudWatchNameSpace,
 				MetricName: &metric.Description,
 				Period:     &period,
 				StartTime:  &metricEndTime,
@@ -169,6 +212,7 @@ func (el *ELBV2Manager) Detect() ([]DetectedELBV2, error) {
 				elbv2 := DetectedELBV2{
 					Region: el.region,
 					Metric: metric.Description,
+					Type:   *instance.Type,
 					PriceDetectedFields: collector.PriceDetectedFields{
 						ResourceID:      *instance.LoadBalancerName,
 						LaunchTime:      *instance.CreatedTime,
@@ -203,33 +247,22 @@ func (el *ELBV2Manager) Detect() ([]DetectedELBV2, error) {
 }
 
 // Get#FilterInput prepare document elb # filter
-func (el *ELBV2Manager) Get#FilterInput() *#.GetProductsInput {
+func (el *ELBV2Manager) Get#FilterInput(extraFilters []*#.Filter) *#.GetProductsInput {
+	filters := []*#.Filter{
+		{
+			Type:  awsClient.String("TERM_MATCH"),
+			Field: awsClient.String("termType"),
+			Value: awsClient.String("OnDemand"),
+		},
+	}
+
+	if extraFilters != nil {
+		filters = append(filters, extraFilters...)
+	}
 
 	return &#.GetProductsInput{
 		ServiceCode: &el.service#Code,
-		Filters: []*#.Filter{
-			{
-				Type:  awsClient.String("TERM_MATCH"),
-				Field: awsClient.String("usagetype"),
-				Value: awsClient.String("LoadBalancerUsage"),
-			},
-			{
-				Type:  awsClient.String("TERM_MATCH"),
-				Field: awsClient.String("productFamily"),
-				Value: awsClient.String("Load Balancer-Application"),
-			},
-			{
-				Type:  awsClient.String("TERM_MATCH"),
-				Field: awsClient.String("TermType"),
-				Value: awsClient.String("OnDemand"),
-			},
-
-			{
-				Type:  awsClient.String("TERM_MATCH"),
-				Field: awsClient.String("group"),
-				Value: awsClient.String("ELB:Balancer"),
-			},
-		},
+		Filters:     filters,
 	}
 }
 
@@ -258,3 +291,14 @@ func (el *ELBV2Manager) DescribeLoadbalancers(marker *string, loadbalancers []*e
 
 	return loadbalancers, nil
 }
+
+// updateErrorServiceStatus reports when elbv2 can't collect data
+func (el *ELBV2Manager) updateErrorServiceStatus(err error) {
+	el.collector.UpdateServiceStatus(collector.EventCollector{
+		ResourceName: el.Name,
+		Data: collector.EventStatusData{
+			Status:       collector.EventError,
+			ErrorMessage: err.Error(),
+		},
+	})
+}