Support unnamed groups in carbon receiver regex parser

Author: grihabor

receiver/carbonreceiver/protocol/regex_parser.go

@@ -168,10 +168,19 @@ func (rpp *regexPathParser) ParsePath(path string, parsedPath *ParsedPath) error
 			attributes := pcommon.NewMap()
 
 			for i := 1; i < len(ms); i++ {
-				if strings.HasPrefix(nms[i], metricNameCapturePrefix) {
-					metricNameLookup[nms[i]] = ms[i]
+				groupName, groupValue := nms[i], ms[i]
+				if groupName == "" {
+					// Skip unnamed groups.
+					continue
+				}
+				if groupValue == "" {
+					// Skip unmatched groups.
+					continue
+				}
+				if strings.HasPrefix(groupName, metricNameCapturePrefix) {
+					metricNameLookup[groupName] = groupValue
 				} else {
-					attributes.PutStr(nms[i][len(keyCapturePrefix):], ms[i])
+					attributes.PutStr(groupName[len(keyCapturePrefix):], groupValue)
 				}
 			}
 

receiver/carbonreceiver/protocol/regex_parser_test.go

@@ -176,6 +176,150 @@ func Test_regexParser_parsePath(t *testing.T) {
 	}
 }
 
+func Test_regexParser_parsePath_simple_unnamed_group(t *testing.T) {
+	config := RegexParserConfig{
+		Rules: []*RegexRule{
+
+			{
+				Regexp:     `(prefix\.)?(?P<key_svc>[^.]+)\.(?P<key_host>[^.]+)\.cpu\.seconds`,
+				NamePrefix: "cpu_seconds",
+			},
+		},
+	}
+
+	require.NoError(t, compileRegexRules(config.Rules))
+	rp := &regexPathParser{
+		rules: config.Rules,
+	}
+
+	tests := []struct {
+		name           string
+		path           string
+		wantName       string
+		wantAttributes pcommon.Map
+		wantMetricType TargetMetricType
+		wantErr        bool
+	}{
+		{
+			name:           "no_rule_match",
+			path:           "service_name.host01.rpc.duration.seconds",
+			wantName:       "service_name.host01.rpc.duration.seconds",
+			wantAttributes: pcommon.NewMap(),
+		},
+		{
+			name:     "match_no_prefix",
+			path:     "service_name.host00.cpu.seconds",
+			wantName: "cpu_seconds",
+			wantAttributes: func() pcommon.Map {
+				m := pcommon.NewMap()
+				m.PutStr("svc", "service_name")
+				m.PutStr("host", "host00")
+				return m
+			}(),
+		},
+		{
+			name:     "match_optional_prefix",
+			path:     "prefix.service_name.host00.cpu.seconds",
+			wantName: "cpu_seconds",
+			wantAttributes: func() pcommon.Map {
+				m := pcommon.NewMap()
+				m.PutStr("svc", "service_name")
+				m.PutStr("host", "host00")
+				return m
+			}(),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := ParsedPath{}
+			err := rp.ParsePath(tt.path, &got)
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+
+			assert.Equal(t, tt.wantName, got.MetricName)
+			assert.Equal(t, tt.wantAttributes, got.Attributes)
+			assert.Equal(t, tt.wantMetricType, got.MetricType)
+		})
+	}
+}
+
+func Test_regexParser_parsePath_key_inside_unnamed_group(t *testing.T) {
+	config := RegexParserConfig{
+		Rules: []*RegexRule{
+
+			{
+				Regexp:     `(job=(?P<key_job>[^.]+).)?(?P<key_svc>[^.]+)\.(?P<key_host>[^.]+)\.cpu\.seconds`,
+				NamePrefix: "cpu_seconds",
+				MetricType: string(GaugeMetricType),
+			},
+		},
+	}
+
+	require.NoError(t, compileRegexRules(config.Rules))
+	rp := &regexPathParser{
+		rules: config.Rules,
+	}
+
+	tests := []struct {
+		name           string
+		path           string
+		wantName       string
+		wantAttributes pcommon.Map
+		wantMetricType TargetMetricType
+		wantErr        bool
+	}{
+		{
+			name:           "no_rule_match",
+			path:           "service_name.host01.rpc.duration.seconds",
+			wantName:       "service_name.host01.rpc.duration.seconds",
+			wantAttributes: pcommon.NewMap(),
+		},
+		{
+			name:     "match_missing_optional_key",
+			path:     "service_name.host00.cpu.seconds",
+			wantName: "cpu_seconds",
+			wantAttributes: func() pcommon.Map {
+				m := pcommon.NewMap()
+				m.PutStr("svc", "service_name")
+				m.PutStr("host", "host00")
+				return m
+			}(),
+			wantMetricType: GaugeMetricType,
+		},
+		{
+			name:     "match_present_optional_key",
+			path:     "job=71972c09-de94-4a4e-a8a7-ad3de050a141.service_name.host00.cpu.seconds",
+			wantName: "cpu_seconds",
+			wantAttributes: func() pcommon.Map {
+				m := pcommon.NewMap()
+				m.PutStr("job", "71972c09-de94-4a4e-a8a7-ad3de050a141")
+				m.PutStr("svc", "service_name")
+				m.PutStr("host", "host00")
+				return m
+			}(),
+			wantMetricType: GaugeMetricType,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := ParsedPath{}
+			err := rp.ParsePath(tt.path, &got)
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+
+			assert.Equal(t, tt.wantName, got.MetricName)
+			assert.Equal(t, tt.wantAttributes, got.Attributes)
+			assert.Equal(t, tt.wantMetricType, got.MetricType)
+		})
+	}
+}
+
 var res struct {
 	name       string
 	attributes pcommon.Map

receiver/carbonreceiver/testdata/config.yaml

@@ -48,7 +48,11 @@ carbon/regex:
           # type is used to select the metric type to be set, the default is
           # "gauge", the other alternative is "cumulative".
           type: cumulative
-        # The second rule for this "regex" parser.
+        # The second rule matches metric with or without a prefix.
+        - regexp: "(optional_prefix\\.)?(?P<key_just>test)\\.(?P<key_match>.*)"
+        # The third rule parses an optional dimension with key "experiment".
+        - regexp: "(experiment(?P<key_experiment>[0-9]+)\\.)?(?P<key_just>test)\\.(?P<key_match>.*)"
+        # The forth rule for this "regex" parser.
         - regexp: "(?P<key_just>test)\\.(?P<key_match>.*)"
       # Name separator is used when concatenating named regular expression
       # captures prefixed with "name_"