rename invalid metrics by partial metrics

Signed-off-by: Augustin Husson <[email protected]>

Author: Nexucis

README.md

@@ -80,16 +80,16 @@ The tool provides an API endpoint, `/api/v1/metrics`, which returns the usage da
 You can used the following query parameter to filter the list returned:
 
 * **metric_name**: when used, it will trigger a fuzzy search on the metric_name based on the pattern provided.
-* **used**: when used, will return only the metric used or not (depending if you set this boolean to true or to false). Leave it empty if you want both.
-* **merge_invalid_metrics**: when used, it will use the data from /api/v1/invalid_metrics and merge them here.
+* **used**: when used, will return only the metric used or not (depending on if you set this boolean to true or to false). Leave it empty if you want both.
+* **merge_invalid_metrics**: when used, it will use the data from /api/v1/partial_metrics and merge them here.
 
-### Invalid Metrics
+### Partial Metrics
 
-The API endpoint `/api/v1/invalid_metrics` is exposing the usage for metrics that contains variable or regexp. 
+The API endpoint `/api/v1/partial_metrics` is exposing the usage for metrics that contains variable or regexp. 
 
 ```json
 {
-  "node_cpu_utilization_${instance}": {
+  "node_disk_discard_time_.+": {
     "usage": {
       "alertRules": [
         {
@@ -101,7 +101,7 @@ The API endpoint `/api/v1/invalid_metrics` is exposing the usage for metrics tha
       ]
     }
   },
-  "node_disk_discard_time_.+": {
+  "node_cpu_utilization_${instance}": {
     "usage": {
       "dashboards": [
         "https://demo.perses.dev/api/v1/projects/perses/dashboards/nodeexporterfull"

database/database.go

@@ -34,29 +34,29 @@ var replaceVariableRegexp = regexp.MustCompile(`\$\{[a-zA-Z0-9_:]+}`)
 type Database interface {
 	GetMetric(name string) *v1.Metric
 	ListMetrics() (map[string]*v1.Metric, error)
-	ListInvalidMetrics() (map[string]*v1.InvalidMetric, error)
+	ListPartialMetrics() (map[string]*v1.PartialMetric, error)
 	ListPendingUsage() map[string]*v1.MetricUsage
 	EnqueueMetricList(metrics []string)
-	EnqueueInvalidMetricsUsage(usages map[string]*v1.MetricUsage)
+	EnqueuePartialMetricsUsage(usages map[string]*v1.MetricUsage)
 	EnqueueUsage(usages map[string]*v1.MetricUsage)
 	EnqueueLabels(labels map[string][]string)
 }
 
 func New(cfg config.Database) Database {
 	d := &db{
 		metrics:                  make(map[string]*v1.Metric),
-		invalidMetrics:           make(map[string]*v1.InvalidMetric),
+		partialMetrics:           make(map[string]*v1.PartialMetric),
 		usage:                    make(map[string]*v1.MetricUsage),
 		usageQueue:               make(chan map[string]*v1.MetricUsage, 250),
-		invalidMetricsUsageQueue: make(chan map[string]*v1.MetricUsage, 250),
+		partialMetricsUsageQueue: make(chan map[string]*v1.MetricUsage, 250),
 		labelsQueue:              make(chan map[string][]string, 250),
 		metricsQueue:             make(chan []string, 10),
 		path:                     cfg.Path,
 	}
 
 	go d.watchUsageQueue()
 	go d.watchMetricsQueue()
-	go d.watchInvalidMetricsUsageQueue()
+	go d.watchPartialMetricsUsageQueue()
 	go d.watchLabelsQueue()
 	if !*cfg.InMemory {
 		if err := d.readMetricsInJSONFile(); err != nil {
@@ -72,8 +72,8 @@ type db struct {
 	// metrics is the list of metric name (as a key) associated to their usage based on the different collector activated.
 	// This struct is our "database".
 	metrics map[string]*v1.Metric
-	// invalidMetrics is the list of metric name that likely contains a variable or a regexp and as such cannot be a valid metric name.
-	invalidMetrics map[string]*v1.InvalidMetric
+	// partialMetrics is the list of metric name that likely contains a variable or a regexp and as such cannot be a valid metric name.
+	partialMetrics map[string]*v1.PartialMetric
 	// usage is a buffer in case the metric name has not yet been collected
 	usage map[string]*v1.MetricUsage
 	// metricsQueue is the channel that should be used to send and receive the list of metric name to keep in memory.
@@ -87,10 +87,10 @@ type db struct {
 	// There will be no other way to write in it.
 	// Doing that allows us to accept more HTTP requests to write data and to delay the actual writing.
 	usageQueue chan map[string]*v1.MetricUsage
-	// invalidMetricsUsageQueue is the way to send the usage per metric that is not valid to write in the database.
+	// partialMetricsUsageQueue is the way to send the usage per metric that is not valid to write in the database.
 	// There will be no other way to write in it.
 	// Doing that allows us to accept more HTTP requests to write data and to delay the actual writing.
-	invalidMetricsUsageQueue chan map[string]*v1.MetricUsage
+	partialMetricsUsageQueue chan map[string]*v1.MetricUsage
 	// path is the path to the JSON file where metrics is flushed periodically
 	// It is empty if the database is purely in memory.
 	path string
@@ -102,7 +102,7 @@ type db struct {
 	// 2. Read the file directly when a read query is coming
 	// Like that we have two different ways to read and write the data.
 	metricsMutex             sync.Mutex
-	invalidMetricsUsageMutex sync.Mutex
+	partialMetricsUsageMutex sync.Mutex
 }
 
 func (d *db) GetMetric(name string) *v1.Metric {
@@ -117,10 +117,10 @@ func (d *db) ListMetrics() (map[string]*v1.Metric, error) {
 	return deep.Copy(d.metrics)
 }
 
-func (d *db) ListInvalidMetrics() (map[string]*v1.InvalidMetric, error) {
-	d.invalidMetricsUsageMutex.Lock()
-	defer d.invalidMetricsUsageMutex.Unlock()
-	return deep.Copy(d.invalidMetrics)
+func (d *db) ListPartialMetrics() (map[string]*v1.PartialMetric, error) {
+	d.partialMetricsUsageMutex.Lock()
+	defer d.partialMetricsUsageMutex.Unlock()
+	return deep.Copy(d.partialMetrics)
 }
 
 func (d *db) EnqueueMetricList(metrics []string) {
@@ -137,8 +137,8 @@ func (d *db) EnqueueUsage(usages map[string]*v1.MetricUsage) {
 	d.usageQueue <- usages
 }
 
-func (d *db) EnqueueInvalidMetricsUsage(usages map[string]*v1.MetricUsage) {
-	d.invalidMetricsUsageQueue <- usages
+func (d *db) EnqueuePartialMetricsUsage(usages map[string]*v1.MetricUsage) {
+	d.partialMetricsUsageQueue <- usages
 }
 
 func (d *db) EnqueueLabels(labels map[string][]string) {
@@ -167,22 +167,22 @@ func (d *db) watchMetricsQueue() {
 	}
 }
 
-func (d *db) watchInvalidMetricsUsageQueue() {
-	for data := range d.invalidMetricsUsageQueue {
-		d.invalidMetricsUsageMutex.Lock()
+func (d *db) watchPartialMetricsUsageQueue() {
+	for data := range d.partialMetricsUsageQueue {
+		d.partialMetricsUsageMutex.Lock()
 		for metricName, usage := range data {
-			if _, ok := d.invalidMetrics[metricName]; !ok {
-				re, matchingMetrics := d.matchInvalidMetric(metricName)
-				d.invalidMetrics[metricName] = &v1.InvalidMetric{
+			if _, ok := d.partialMetrics[metricName]; !ok {
+				re, matchingMetrics := d.matchPartialMetric(metricName)
+				d.partialMetrics[metricName] = &v1.PartialMetric{
 					Usage:           usage,
 					MatchingMetrics: matchingMetrics,
 					MatchingRegexp:  re,
 				}
 			} else {
-				d.invalidMetrics[metricName].Usage = v1.MergeUsage(d.invalidMetrics[metricName].Usage, usage)
+				d.partialMetrics[metricName].Usage = v1.MergeUsage(d.partialMetrics[metricName].Usage, usage)
 			}
 		}
-		d.invalidMetricsUsageMutex.Unlock()
+		d.partialMetricsUsageMutex.Unlock()
 	}
 }
 
@@ -253,10 +253,10 @@ func (d *db) readMetricsInJSONFile() error {
 	return json.Unmarshal(data, &d.metrics)
 }
 
-func (d *db) matchInvalidMetric(invalidMetric string) (*common.Regexp, v1.Set[string]) {
-	re, err := generateRegexp(invalidMetric)
+func (d *db) matchPartialMetric(partialMetric string) (*common.Regexp, v1.Set[string]) {
+	re, err := generateRegexp(partialMetric)
 	if err != nil {
-		logrus.WithError(err).Errorf("unable to compile the invalid metric name %q into a regexp", invalidMetric)
+		logrus.WithError(err).Errorf("unable to compile the partial metric name %q into a regexp", partialMetric)
 		return nil, nil
 	}
 	if re == nil {
@@ -274,45 +274,45 @@ func (d *db) matchInvalidMetric(invalidMetric string) (*common.Regexp, v1.Set[st
 }
 
 func (d *db) matchValidMetric(validMetric string) {
-	d.invalidMetricsUsageMutex.Lock()
-	defer d.invalidMetricsUsageMutex.Unlock()
-	for metricName, invalidMetric := range d.invalidMetrics {
-		re := invalidMetric.MatchingRegexp
+	d.partialMetricsUsageMutex.Lock()
+	defer d.partialMetricsUsageMutex.Unlock()
+	for metricName, partialMetric := range d.partialMetrics {
+		re := partialMetric.MatchingRegexp
 		if re == nil {
 			var err error
 			re, err = generateRegexp(metricName)
 			if err != nil {
-				logrus.WithError(err).Errorf("unable to compile the invalid metric name %q into a regexp", metricName)
+				logrus.WithError(err).Errorf("unable to compile the partial metric name %q into a regexp", metricName)
 				continue
 			}
-			invalidMetric.MatchingRegexp = re
+			partialMetric.MatchingRegexp = re
 			if re == nil {
 				continue
 			}
 		}
 		if re.MatchString(validMetric) {
-			matchingMetrics := invalidMetric.MatchingMetrics
+			matchingMetrics := partialMetric.MatchingMetrics
 			if matchingMetrics == nil {
 				matchingMetrics = v1.NewSet[string]()
-				invalidMetric.MatchingMetrics = matchingMetrics
+				partialMetric.MatchingMetrics = matchingMetrics
 			}
 			matchingMetrics.Add(validMetric)
 		}
 	}
 }
 
-// GenerateRegexp is taking an invalid metric name,
+// GenerateRegexp is taking an partial metric name,
 // will replace every variable by a pattern and then returning a regepx if the final string is not just equal to .*.
-func generateRegexp(invalidMetricName string) (*common.Regexp, error) {
+func generateRegexp(partialMetricName string) (*common.Regexp, error) {
 	// The first step is to replace every variable by a single special char.
 	// We are using a special single char because it will be easier to find if these chars are continuous
 	// or if there are other characters in between.
-	s := replaceVariableRegexp.ReplaceAllString(invalidMetricName, "#")
+	s := replaceVariableRegexp.ReplaceAllString(partialMetricName, "#")
 	s = strings.ReplaceAll(s, ".+", "#")
 	s = strings.ReplaceAll(s, ".*", "#")
 	if s == "#" || len(s) == 0 {
 		// This means the metric name is just a variable and as such can match all metric.
-		// So it's basically impossible to know what this invalid metric name is covering/matching.
+		// So it's basically impossible to know what this partial metric name is covering/matching.
 		return nil, nil
 	}
 	// The next step is to contact every continuous special char '#' to a single one.

database/database_test.go

@@ -28,39 +28,39 @@ func newRegexp(re string) *common.Regexp {
 func TestGenerateRegexp(t *testing.T) {
 	tests := []struct {
 		title         string
-		invalidMetric string
+		partialMetric string
 		result        *common.Regexp
 	}{
 		{
 			title:         "metric equal to a variable",
-			invalidMetric: "${metric}",
+			partialMetric: "${metric}",
 			result:        nil,
 		},
 		{
 			title:         "metric with variable a suffix",
-			invalidMetric: "otelcol_exporter_enqueue_failed_log_records${suffix}",
+			partialMetric: "otelcol_exporter_enqueue_failed_log_records${suffix}",
 			result:        newRegexp(`^otelcol_exporter_enqueue_failed_log_records.+$`),
 		},
 		{
 			title:         "metric with multiple variable 1",
-			invalidMetric: "${foo}${bar}${john}${doe}",
+			partialMetric: "${foo}${bar}${john}${doe}",
 			result:        nil,
 		},
 		{
 			title:         "metric with multiple variable 2",
-			invalidMetric: "prefix_${foo}${bar}:collection_${collection}_suffix:${john}${doe}",
+			partialMetric: "prefix_${foo}${bar}:collection_${collection}_suffix:${john}${doe}",
 			result:        newRegexp(`^prefix_.+:collection_.+_suffix:.+$`),
 		},
 		{
 			title:         "metric no variable",
-			invalidMetric: "otelcol_receiver_.+",
+			partialMetric: "otelcol_receiver_.+",
 			result:        newRegexp(`^otelcol_receiver_.+$`),
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.title, func(t *testing.T) {
-			re, err := generateRegexp(test.invalidMetric)
+			re, err := generateRegexp(test.partialMetric)
 			assert.NoError(t, err)
 			assert.Equal(t, test.result, re)
 		})

pkg/analyze/grafana/grafana.go

@@ -165,22 +165,22 @@ func Analyze(dashboard *SimplifiedDashboard) (modelAPIV1.Set[string], modelAPIV1
 func extractMetricsFromPanels(panels []Panel, staticVariables *strings.Replacer, allVariableNames modelAPIV1.Set[string], dashboard *SimplifiedDashboard) (modelAPIV1.Set[string], modelAPIV1.Set[string], []*modelAPIV1.LogError) {
 	var errs []*modelAPIV1.LogError
 	result := modelAPIV1.Set[string]{}
-	invalidMetricsResult := modelAPIV1.Set[string]{}
+	partialMetricsResult := modelAPIV1.Set[string]{}
 	for _, p := range panels {
 		for _, t := range extractTarget(p) {
 			if len(t.Expr) == 0 {
 				continue
 			}
 			exprWithVariableReplaced := replaceVariables(t.Expr, staticVariables)
-			metrics, invalidMetrics, err := prometheus.AnalyzePromQLExpression(exprWithVariableReplaced)
+			metrics, partialMetrics, err := prometheus.AnalyzePromQLExpression(exprWithVariableReplaced)
 			if err != nil {
 				otherMetrics := parser.ExtractMetricNameWithVariable(exprWithVariableReplaced)
 				if len(otherMetrics) > 0 {
 					for m := range otherMetrics {
 						if prometheus.IsValidMetricName(m) {
 							result.Add(m)
 						} else {
-							invalidMetricsResult.Add(formatVariableInMetricName(m, allVariableNames))
+							partialMetricsResult.Add(formatVariableInMetricName(m, allVariableNames))
 						}
 					}
 				} else {
@@ -191,24 +191,25 @@ func extractMetricsFromPanels(panels []Panel, staticVariables *strings.Replacer,
 				}
 			} else {
 				result.Merge(metrics)
-				invalidMetricsResult.Merge(invalidMetrics)
+				partialMetricsResult.Merge(partialMetrics)
 			}
 		}
 	}
-	return result, invalidMetricsResult, errs
+	return result, partialMetricsResult, errs
 }
 
 func extractMetricsFromVariables(variables []templateVar, staticVariables *strings.Replacer, allVariableNames modelAPIV1.Set[string], dashboard *SimplifiedDashboard) (modelAPIV1.Set[string], modelAPIV1.Set[string], []*modelAPIV1.LogError) {
 	var errs []*modelAPIV1.LogError
 	result := modelAPIV1.Set[string]{}
-	invalidMetricsResult := modelAPIV1.Set[string]{}
+	partialMetricsResult := modelAPIV1.Set[string]{}
 	for _, v := range variables {
 		if v.Type != "query" {
 			continue
 		}
 		query, err := v.extractQueryFromVariableTemplating()
 		if err != nil {
-			// It appears when there is an issue, we cannot do anything about it actually and usually the variable is not the one we are looking for.
+			// It appears when there is an issue, we cannot do anything about it,
+			// and usually the variable is not the one we are looking for.
 			// So we just log it as a warning
 			errs = append(errs, &modelAPIV1.LogError{
 				Warning: err,
@@ -232,21 +233,21 @@ func extractMetricsFromVariables(variables []templateVar, staticVariables *strin
 			query = queryResultRegexp.FindStringSubmatch(query)[1]
 			// metrics(.*partial_metric_name)
 		} else if metricsRegexp.MatchString(query) {
-			// for this particular use case, the query is an invalid metric names so there is no need to use the PromQL parser.
+			// for this particular use case, the query is a partial metric names so there is no need to use the PromQL parser.
 			query = metricsRegexp.FindStringSubmatch(query)[1]
-			invalidMetricsResult.Add(formatVariableInMetricName(query, allVariableNames))
+			partialMetricsResult.Add(formatVariableInMetricName(query, allVariableNames))
 			continue
 		}
 		exprWithVariableReplaced := replaceVariables(query, staticVariables)
-		metrics, invalidMetrics, err := prometheus.AnalyzePromQLExpression(exprWithVariableReplaced)
+		metrics, partialMetrics, err := prometheus.AnalyzePromQLExpression(exprWithVariableReplaced)
 		if err != nil {
 			otherMetrics := parser.ExtractMetricNameWithVariable(exprWithVariableReplaced)
 			if len(otherMetrics) > 0 {
 				for m := range otherMetrics {
 					if prometheus.IsValidMetricName(m) {
 						result.Add(m)
 					} else {
-						invalidMetricsResult.Add(formatVariableInMetricName(m, allVariableNames))
+						partialMetricsResult.Add(formatVariableInMetricName(m, allVariableNames))
 					}
 				}
 			} else {
@@ -257,10 +258,10 @@ func extractMetricsFromVariables(variables []templateVar, staticVariables *strin
 			}
 		} else {
 			result.Merge(metrics)
-			invalidMetricsResult.Merge(invalidMetrics)
+			partialMetricsResult.Merge(partialMetrics)
 		}
 	}
-	return result, invalidMetricsResult, errs
+	return result, partialMetricsResult, errs
 }
 
 func extractStaticVariables(variables []templateVar) map[string]string {

pkg/analyze/grafana/grafana_test.go

@@ -121,9 +121,9 @@ func TestAnalyze(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			metrics, invalidMetrics, errs := Analyze(dashboard)
+			metrics, partialMetrics, errs := Analyze(dashboard)
 			metricsAsSlice := metrics.TransformAsSlice()
-			invalidMetricsAsSlice := invalidMetrics.TransformAsSlice()
+			invalidMetricsAsSlice := partialMetrics.TransformAsSlice()
 			slices.Sort(metricsAsSlice)
 			slices.Sort(invalidMetricsAsSlice)
 			assert.Equal(t, tt.resultMetrics, metricsAsSlice)