Performance Tracking Integration Test and Data Collection

integration/test/performance_tracker/get_performance_metrics.go

@@ -0,0 +1,53 @@
+package data_collector
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
+)
+
+//integration tests run on us-west-2
+const region = "us-west-2"
+
+func GetPerformanceMetrics(instanceId string, runtimeSeconds int) (error) {
+	//load default configuration
+	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(region))
+	if err != nil {
+		return err
+	}
+
+	client := cloudwatch.NewFromConfig(cfg)
+
+	//declare metrics you want to gather from cloudwatch agent
+	ids := []string{"m1", "m2"}
+	metricNames := []string{"procstat_cpu_usage", "procstat_memory_rss"}
+
+	//give a 30 second buffer before metrics collection to allow for agent startup
+	runtimeSeconds -= 30
+	input, err := GenerateGetMetricInputStruct(ids, metricNames, instanceId, runtimeSeconds)
+	if err != nil {
+		return err
+	}
+
+	//call to cloudwatch agent API
+	metrics, err := GetMetrics(context.TODO(), client, input)
+	if err != nil {
+		return err
+	}
+
+	//format data to json before passing output
+	outputData, err := json.MarshalIndent(metrics.MetricDataResults, "", "  ")
+	if err != nil {
+		return err
+    }
+
+	//------ PASS TO DATABASE TRANSMITTER HERE------//
+	//useless code so that outputData is used and compiles
+	if outputData != nil {
+		return nil
+	}
+
+	return nil
+}

integration/test/performance_tracker/performance_metrics_test.go

@@ -0,0 +1,44 @@
+//go:build linux && integration
+// +build linux,integration
+
+package data_collector
+
+import(
+	"testing"
+	"time"
+	"log"
+
+	"github.com/aws/amazon-cloudwatch-agent/integration/test"
+)
+
+const (
+	configPath = "resources/config.json"
+	configOutputPath = "/opt/aws/amazon-cloudwatch-agent/bin/config.json"
+	agentRuntime = 20 * time.Minute
+)
+
+func PerformanceTest(t *testing.T) {
+
+	instanceId := test.GetInstanceId()
+	log.Println("Instance ID used for performance metrics : %s", instanceId)
+
+	test.CopyFile(configPath, configOutputPath)
+
+	test.StartAgent(configOutputPath, true)
+
+	//let agent run before collecting performance metrics on it
+	time.Sleep(agentRuntime)
+	log.Printf("Agent has been running for : %s", agentRuntime.String())
+
+	//convert to int seconds for use in data collection
+	runtimeSeconds := int(agentRuntime / time.Second)
+
+	//collect data
+	err := GetPerformanceMetrics(instanceId, runtimeSeconds)
+	if (err != nil) {
+		log.Println("Error: " + err)
+		t.Fatalf("Error: %v", err)
+	}
+
+	test.StopAgent()
+}

integration/test/performance_tracker/performance_query_utils.go

@@ -0,0 +1,78 @@
+package data_collector
+
+import (
+	"time"
+	"context"
+	"errors"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatch/types"
+)
+
+const (
+	Namespace = "CWAgent"
+	DimensionName = "InstanceId"
+	Stat = "Average"
+	Period = 30
+)
+
+// CWGetMetricDataAPI defines the interface for the GetMetricData function
+type CWGetMetricDataAPI interface {
+	GetMetricData(ctx context.Context, params *cloudwatch.GetMetricDataInput, optFns ...func(*cloudwatch.Options)) (*cloudwatch.GetMetricDataOutput, error)
+}
+
+// GetMetrics Fetches the cloudwatch metrics for your provided input in the given time-frame
+func GetMetrics(c context.Context, api CWGetMetricDataAPI, input *cloudwatch.GetMetricDataInput) (*cloudwatch.GetMetricDataOutput, error) {
+	return api.GetMetricData(c, input)
+}
+
+// GenerateGetMetricInputStruct generates the struct required to make a query request to cloudwatch's GetMetrics
+func GenerateGetMetricInputStruct(ids []string, metricNames []string, instanceId string, timeDiff int) (*cloudwatch.GetMetricDataInput, error) {
+	if len(ids) != len(metricNames) {
+		return nil, errors.New("Mismatching lengths of metric ids and metricNames")
+	}
+
+	if len(ids) == 0 || len(metricNames) == 0 || instanceId == "" || timeDiff == 0 {
+		return nil, errors.New("Must supply metric ids, metric names, instance id, and time to collect metrics")
+	}
+
+	dimensionValue := instanceId
+	metricDataQueries := []types.MetricDataQuery{}
+
+	//generate list of individual metric requests
+	for i := 0; i < len(ids); i++ {
+		metricDataQueries = append(metricDataQueries, ConstructMetricDataQuery(ids[i], Namespace, DimensionName, dimensionValue, metricNames[i], timeDiff))
+	}
+
+	input := &cloudwatch.GetMetricDataInput{
+		EndTime:   aws.Time(time.Unix(time.Now().Unix(), 0)),
+		StartTime: aws.Time(time.Unix(time.Now().Add(time.Duration(-timeDiff)*time.Minute).Unix(), 0)),
+		MetricDataQueries: metricDataQueries,
+	}
+
+	return input, nil
+}
+
+// ConstructMetricDataQuery is a helper function for GenerateGetMetricInputStruct and constructs individual metric requests
+func ConstructMetricDataQuery(id string, namespace string, dimensionName string, dimensionValue string, metricName string, timeDiff int) (types.MetricDataQuery) {
+	query := types.MetricDataQuery{
+		Id: aws.String(id),
+		MetricStat: &types.MetricStat{
+			Metric: &types.Metric{
+				Namespace:  aws.String(namespace),
+				MetricName: aws.String(metricName),
+				Dimensions: []types.Dimension{
+					types.Dimension{
+						Name:  aws.String(dimensionName),
+						Value: aws.String(dimensionValue),
+					},
+				},
+			},
+			Period: aws.Int32(int32(Period)),
+			Stat:   aws.String(Stat),
+		},
+	}
+
+	return query
+}

integration/test/performance_tracker/resources/config.json

@@ -0,0 +1,50 @@
+{
+	"agent": {
+		"metrics_collection_interval": 60,
+		"run_as_user": "root"
+	},
+	"metrics": {
+		"aggregation_dimensions": [
+			[
+				"InstanceId"
+			]
+		],
+		"append_dimensions": {
+			"AutoScalingGroupName": "${aws:AutoScalingGroupName}",
+			"ImageId": "${aws:ImageId}",
+			"InstanceId": "${aws:InstanceId}",
+			"InstanceType": "${aws:InstanceType}"
+		},
+		"metrics_collected": {
+			"disk": {
+				"measurement": [
+					"used_percent"
+				],
+				"metrics_collection_interval": 60,
+				"resources": [
+					"*"
+				]
+			},
+			"mem": {
+				"measurement": [
+					"mem_used_percent"
+				],
+				"metrics_collection_interval": 60
+			},
+			"statsd": {
+				"metrics_aggregation_interval": 60,
+				"metrics_collection_interval": 10,
+				"service_address": ":8125"
+			},
+            "procstat": [
+                {
+                    "exe": "cloudwatch-agent",
+                    "measurement": [
+                        "cpu_usage",
+						"memory_rss"
+                    ]
+                }
+            ]
+		}
+	}
+}