Feat review comments

src/query-performance-monitoring/common-utils/constants.go

@@ -2,8 +2,13 @@ package commonutils
 
 import "errors"
 
-const MaxQueryThreshold = 30
-const MaxIndividualQueryThreshold = 10
+// The maximum number records that can be fetched in a single metrics
+const MaxQueryCountThreshold = 30
+
+// The maximum number of individual queries that can be fetched in a single metrics
+const MaxIndividualQueryCountThreshold = 10
+
+// The maximum number of metrics to be published in a single batch
 const PublishThreshold = 100
 const RandomIntRange = 1000000
 const TimeFormat = "20060102150405"

src/query-performance-monitoring/common-utils/ingestion-helpers.go

@@ -74,7 +74,7 @@ func IngestMetric(metricList []interface{}, eventName string, pgIntegration *int
 }
 
 func CreateEntity(pgIntegration *integration.Integration, gv *globalvariables.GlobalVariables) (*integration.Entity, error) {
-	return pgIntegration.Entity(fmt.Sprintf("%s:%s", gv.Hostname, gv.Port), "pg-instance")
+	return pgIntegration.Entity(fmt.Sprintf("%s:%s", gv.Arguments.Hostname, gv.Arguments.Port), "pg-instance")
 }
 
 func ProcessModel(model interface{}, metricSet *metric.Set) error {

src/query-performance-monitoring/global-variables/global_variables.go

@@ -5,23 +5,15 @@ import (
 )
 
 type GlobalVariables struct {
-	QueryResponseTimeThreshold int
-	QueryCountThreshold        int
-	Version                    uint64
-	DatabaseString             string
-	Hostname                   string
-	Port                       string
-	Arguments                  args.ArgumentList
+	Version        uint64
+	DatabaseString string
+	Arguments      args.ArgumentList
 }
 
 func SetGlobalVariables(args args.ArgumentList, version uint64, databaseString string) *GlobalVariables {
 	return &GlobalVariables{
-		QueryResponseTimeThreshold: args.QueryResponseTimeThreshold,
-		QueryCountThreshold:        args.QueryCountThreshold,
-		Version:                    version,
-		DatabaseString:             databaseString,
-		Hostname:                   args.Hostname,
-		Port:                       args.Port,
-		Arguments:                  args,
+		Version:        version,
+		DatabaseString: databaseString,
+		Arguments:      args,
 	}
 }

src/query-performance-monitoring/performance-metrics/blocking_sessions.go

@@ -43,7 +43,7 @@ func GetBlockingMetrics(conn *performancedbconnection.PGSQLConnection, gv *globa
 		log.Error("Unsupported postgres version: %v", err)
 		return nil, err
 	}
-	var query = fmt.Sprintf(versionSpecificBlockingQuery, gv.DatabaseString, min(gv.QueryCountThreshold, commonutils.MaxQueryThreshold))
+	var query = fmt.Sprintf(versionSpecificBlockingQuery, gv.DatabaseString, min(gv.Arguments.QueryCountThreshold, commonutils.MaxQueryCountThreshold))
 	rows, err := conn.Queryx(query)
 	if err != nil {
 		log.Error("Failed to execute query: %v", err)

src/query-performance-monitoring/performance-metrics/blocking_sessions_test.go

@@ -23,7 +23,7 @@ func TestGetBlockingMetrics(t *testing.T) {
 	gv := global_variables.SetGlobalVariables(args, version, databaseName)
 
 	expectedQuery := queries.BlockingQueriesForV12AndV13
-	query := fmt.Sprintf(expectedQuery, databaseName, min(args.QueryCountThreshold, commonutils.MaxQueryThreshold))
+	query := fmt.Sprintf(expectedQuery, databaseName, min(args.QueryCountThreshold, commonutils.MaxQueryCountThreshold))
 	mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
 		"newrelic", "blocked_pid", "blocked_query", "blocked_query_id", "blocked_query_start", "database_name",
 		"blocking_pid", "blocking_query", "blocking_query_id", "blocking_query_start",

src/query-performance-monitoring/performance-metrics/individual_query_metrics.go

@@ -56,7 +56,7 @@ func GetIndividualQueryMetrics(conn *performancedbconnection.PGSQLConnection, sl
 }
 
 func getIndividualQueriesSamples(conn *performancedbconnection.PGSQLConnection, slowRunningQueries datamodels.SlowRunningQueryMetrics, gv *globalvariables.GlobalVariables, anonymizedQueriesByDB map[string]map[string]string, individualQueryMetricsForExecPlanList *[]datamodels.IndividualQueryMetrics, individualQueryMetricsListInterface *[]interface{}, versionSpecificIndividualQuery string) {
-	query := fmt.Sprintf(versionSpecificIndividualQuery, *slowRunningQueries.QueryID, gv.DatabaseString, gv.QueryResponseTimeThreshold, min(gv.QueryCountThreshold, commonutils.MaxIndividualQueryThreshold))
+	query := fmt.Sprintf(versionSpecificIndividualQuery, *slowRunningQueries.QueryID, gv.DatabaseString, gv.Arguments.QueryResponseTimeThreshold, min(gv.Arguments.QueryCountThreshold, commonutils.MaxIndividualQueryCountThreshold))
 	if query == "" {
 		log.Debug("Error constructing individual query")
 		return

src/query-performance-monitoring/performance-metrics/individual_query_metrics_test.go

@@ -26,7 +26,7 @@ func TestGetIndividualQueryMetrics(t *testing.T) {
 	gv := global_variables.SetGlobalVariables(args, version, databaseName)
 
 	// Mock the individual query
-	query := fmt.Sprintf(queries.IndividualQuerySearchV13AndAbove, mockQueryID, databaseName, args.QueryResponseTimeThreshold, min(args.QueryCountThreshold, commonutils.MaxIndividualQueryThreshold))
+	query := fmt.Sprintf(queries.IndividualQuerySearchV13AndAbove, mockQueryID, databaseName, args.QueryResponseTimeThreshold, min(args.QueryCountThreshold, commonutils.MaxIndividualQueryCountThreshold))
 	mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
 		"newrelic", "query", "queryid", "datname", "planid", "avg_cpu_time_ms", "avg_exec_time_ms",
 	}).AddRow(

src/query-performance-monitoring/performance-metrics/slow_query_metrics.go

@@ -20,7 +20,7 @@ func GetSlowRunningMetrics(conn *performancedbconnection.PGSQLConnection, gv *gl
 		log.Error("Unsupported postgres version: %v", err)
 		return nil, nil, err
 	}
-	var query = fmt.Sprintf(versionSpecificSlowQuery, gv.DatabaseString, min(gv.QueryCountThreshold, commonutils.MaxQueryThreshold))
+	var query = fmt.Sprintf(versionSpecificSlowQuery, gv.DatabaseString, min(gv.Arguments.QueryCountThreshold, commonutils.MaxQueryCountThreshold))
 	rows, err := conn.Queryx(query)
 	if err != nil {
 		return nil, nil, err

src/query-performance-monitoring/performance-metrics/slow_query_metrics_test.go

@@ -21,7 +21,7 @@ func runSlowQueryTest(t *testing.T, query string, version uint64, expectedLength
 	databaseName := "testdb"
 	gv := global_variables.SetGlobalVariables(args, version, databaseName)
 
-	query = fmt.Sprintf(query, "testdb", min(args.QueryCountThreshold, commonutils.MaxQueryThreshold))
+	query = fmt.Sprintf(query, "testdb", min(args.QueryCountThreshold, commonutils.MaxQueryCountThreshold))
 	mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
 		"newrelic", "query_id", "query_text", "database_name", "schema_name", "execution_count",
 		"avg_elapsed_time_ms", "avg_disk_reads", "avg_disk_writes", "statement_type", "collection_timestamp",
@@ -50,7 +50,7 @@ func TestGetSlowRunningEmptyMetrics(t *testing.T) {
 	version := uint64(13)
 	gv := global_variables.SetGlobalVariables(args, version, databaseName)
 	expectedQuery := queries.SlowQueriesForV13AndAbove
-	query := fmt.Sprintf(expectedQuery, "testdb", min(args.QueryCountThreshold, commonutils.MaxQueryThreshold))
+	query := fmt.Sprintf(expectedQuery, "testdb", min(args.QueryCountThreshold, commonutils.MaxQueryCountThreshold))
 	mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
 		"newrelic", "query_id", "query_text", "database_name", "schema_name", "execution_count",
 		"avg_elapsed_time_ms", "avg_disk_reads", "avg_disk_writes", "statement_type", "collection_timestamp",

src/query-performance-monitoring/performance-metrics/wait_event_metrics.go

@@ -40,7 +40,7 @@ func PopulateWaitEventMetrics(conn *performancedbconnection.PGSQLConnection, pgI
 
 func GetWaitEventMetrics(conn *performancedbconnection.PGSQLConnection, gv *globalvariables.GlobalVariables) ([]interface{}, error) {
 	var waitEventMetricsList []interface{}
-	var query = fmt.Sprintf(queries.WaitEvents, gv.DatabaseString, min(gv.QueryCountThreshold, commonutils.MaxQueryThreshold))
+	var query = fmt.Sprintf(queries.WaitEvents, gv.DatabaseString, min(gv.Arguments.QueryCountThreshold, commonutils.MaxQueryCountThreshold))
 	rows, err := conn.Queryx(query)
 	if err != nil {
 		return nil, err

src/query-performance-monitoring/performance-metrics/wait_event_metrics_test.go

@@ -21,7 +21,7 @@ func TestGetWaitEventMetrics(t *testing.T) {
 	databaseName := "testdb"
 	gv := global_variables.SetGlobalVariables(args, uint64(14), databaseName)
 
-	var query = fmt.Sprintf(queries.WaitEvents, databaseName, min(args.QueryCountThreshold, commonutils.MaxQueryThreshold))
+	var query = fmt.Sprintf(queries.WaitEvents, databaseName, min(args.QueryCountThreshold, commonutils.MaxQueryCountThreshold))
 	mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
 		"wait_event_name", "wait_category", "total_wait_time_ms", "collection_timestamp", "query_id", "query_text", "database_name",
 	}).AddRow(
@@ -40,7 +40,7 @@ func TestGetWaitEventEmptyMetrics(t *testing.T) {
 	databaseName := "testdb"
 	gv := global_variables.SetGlobalVariables(args, uint64(14), databaseName)
 
-	var query = fmt.Sprintf(queries.WaitEvents, databaseName, min(args.QueryCountThreshold, commonutils.MaxQueryThreshold))
+	var query = fmt.Sprintf(queries.WaitEvents, databaseName, min(args.QueryCountThreshold, commonutils.MaxQueryCountThreshold))
 	mock.ExpectQuery(regexp.QuoteMeta(query)).WillReturnRows(sqlmock.NewRows([]string{
 		"wait_event_name", "wait_category", "total_wait_time_ms", "collection_timestamp", "query_id", "query_text", "database_name",
 	}))