Adds support for line-column numbers for invalid rules, promtool (#6533)

Signed-off-by: Harkishen Singh <harkishensingh@hotmail.com>

cmd/promtool/main.go

@@ -347,11 +347,11 @@ func checkDuplicates(groups []rulefmt.RuleGroup) []compareRuleType {
 	return duplicates
 }
 
-func ruleMetric(rule rulefmt.Rule) string {
-	if rule.Alert != "" {
-		return rule.Alert
+func ruleMetric(rule rulefmt.RuleNode) string {
+	if rule.Alert.Value != "" {
+		return rule.Alert.Value
 	}
-	return rule.Record
+	return rule.Record.Value
 }
 
 var checkMetricsUsage = strings.TrimSpace(`

go.mod

@@ -50,6 +50,7 @@ require (
 	gopkg.in/alecthomas/kingpin.v2 v2.2.6
 	gopkg.in/fsnotify/fsnotify.v1 v1.4.7
 	gopkg.in/yaml.v2 v2.2.2
+	gopkg.in/yaml.v3 v3.0.0-20191120175047-4206685974f2
 	k8s.io/api v0.0.0-20190813020757-36bff7324fb7
 	k8s.io/apimachinery v0.0.0-20190809020650-423f5d784010
 	k8s.io/client-go v0.0.0-20190620085101-78d2af792bab

go.sum

@@ -482,6 +482,8 @@ gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bl
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20191120175047-4206685974f2 h1:XZx7nhd5GMaZpmDaEHFVafUZC7ya0fuo7cSJ3UCKYmM=
+gopkg.in/yaml.v3 v3.0.0-20191120175047-4206685974f2/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

pkg/rulefmt/rulefmt.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prometheus/common/model"
-	yaml "gopkg.in/yaml.v2"
+	yaml "gopkg.in/yaml.v3"
 
 	"github.com/prometheus/prometheus/pkg/timestamp"
 	"github.com/prometheus/prometheus/promql"
@@ -33,11 +33,24 @@ type Error struct {
 	Group    string
 	Rule     int
 	RuleName string
-	Err      error
+	Err      WrappedError
+}
+
+// WrappedError wraps error with the yaml node which can be used to represent
+// the line and column numbers of the error.
+type WrappedError struct {
+	err     error
+	node    *yaml.Node
+	nodeAlt *yaml.Node
 }
 
 func (err *Error) Error() string {
-	return errors.Wrapf(err.Err, "group %q, rule %d, %q", err.Group, err.Rule, err.RuleName).Error()
+	if err.Err.nodeAlt != nil {
+		return errors.Wrapf(err.Err.err, "%d:%d: %d:%d: group %q, rule %d, %q", err.Err.node.Line, err.Err.node.Column, err.Err.nodeAlt.Line, err.Err.nodeAlt.Column, err.Group, err.Rule, err.RuleName).Error()
+	} else if err.Err.node != nil {
+		return errors.Wrapf(err.Err.err, "%d:%d: group %q, rule %d, %q", err.Err.node.Line, err.Err.node.Column, err.Group, err.Rule, err.RuleName).Error()
+	}
+	return errors.Wrapf(err.Err.err, "group %q, rule %d, %q", err.Group, err.Rule, err.RuleName).Error()
 }
 
 // RuleGroups is a set of rule groups that are typically exposed in a file.
@@ -45,28 +58,32 @@ type RuleGroups struct {
 	Groups []RuleGroup `yaml:"groups"`
 }
 
+type ruleGroups struct {
+	Groups []yaml.Node `yaml:"groups"`
+}
+
 // Validate validates all rules in the rule groups.
-func (g *RuleGroups) Validate() (errs []error) {
+func (g *RuleGroups) Validate(node ruleGroups) (errs []error) {
 	set := map[string]struct{}{}
 
-	for _, g := range g.Groups {
+	for j, g := range g.Groups {
 		if g.Name == "" {
-			errs = append(errs, errors.Errorf("Groupname should not be empty"))
+			errs = append(errs, errors.Errorf("%d:%d: Groupname should not be empty", node.Groups[j].Line, node.Groups[j].Column))
 		}
 
 		if _, ok := set[g.Name]; ok {
 			errs = append(
 				errs,
-				errors.Errorf("groupname: \"%s\" is repeated in the same file", g.Name),
+				errors.Errorf("%d:%d: groupname: \"%s\" is repeated in the same file", node.Groups[j].Line, node.Groups[j].Column, g.Name),
 			)
 		}
 
 		set[g.Name] = struct{}{}
 
 		for i, r := range g.Rules {
-			for _, err := range r.Validate() {
-				var ruleName string
-				if r.Alert != "" {
+			for _, node := range r.Validate() {
+				var ruleName yaml.Node
+				if r.Alert.Value != "" {
 					ruleName = r.Alert
 				} else {
 					ruleName = r.Record
@@ -74,8 +91,8 @@ func (g *RuleGroups) Validate() (errs []error) {
 				errs = append(errs, &Error{
 					Group:    g.Name,
 					Rule:     i,
-					RuleName: ruleName,
-					Err:      err,
+					RuleName: ruleName.Value,
+					Err:      node,
 				})
 			}
 		}
@@ -88,7 +105,7 @@ func (g *RuleGroups) Validate() (errs []error) {
 type RuleGroup struct {
 	Name     string         `yaml:"name"`
 	Interval model.Duration `yaml:"interval,omitempty"`
-	Rules    []Rule         `yaml:"rules"`
+	Rules    []RuleNode     `yaml:"rules"`
 }
 
 // Rule describes an alerting or recording rule.
@@ -101,55 +118,104 @@ type Rule struct {
 	Annotations map[string]string `yaml:"annotations,omitempty"`
 }
 
+// RuleNode adds yaml.v3 layer to support line and column outputs for invalid rules.
+type RuleNode struct {
+	Record      yaml.Node         `yaml:"record,omitempty"`
+	Alert       yaml.Node         `yaml:"alert,omitempty"`
+	Expr        yaml.Node         `yaml:"expr"`
+	For         model.Duration    `yaml:"for,omitempty"`
+	Labels      map[string]string `yaml:"labels,omitempty"`
+	Annotations map[string]string `yaml:"annotations,omitempty"`
+}
+
 // Validate the rule and return a list of encountered errors.
-func (r *Rule) Validate() (errs []error) {
-	if r.Record != "" && r.Alert != "" {
-		errs = append(errs, errors.Errorf("only one of 'record' and 'alert' must be set"))
+func (r *RuleNode) Validate() (nodes []WrappedError) {
+	if r.Record.Value != "" && r.Alert.Value != "" {
+		nodes = append(nodes, WrappedError{
+			err:     errors.Errorf("only one of 'record' and 'alert' must be set"),
+			node:    &r.Record,
+			nodeAlt: &r.Alert,
+		})
+	}
+	if r.Record.Value == "" && r.Alert.Value == "" {
+		if r.Record.Value == "0" {
+			nodes = append(nodes, WrappedError{
+				err:  errors.Errorf("one of 'record' or 'alert' must be set"),
+				node: &r.Alert,
+			})
+		} else {
+			nodes = append(nodes, WrappedError{
+				err:  errors.Errorf("one of 'record' or 'alert' must be set"),
+				node: &r.Record,
+			})
 		}
-	if r.Record == "" && r.Alert == "" {
-		errs = append(errs, errors.Errorf("one of 'record' or 'alert' must be set"))
 	}
 
-	if r.Expr == "" {
-		errs = append(errs, errors.Errorf("field 'expr' must be set in rule"))
-	} else if _, err := promql.ParseExpr(r.Expr); err != nil {
-		errs = append(errs, errors.Wrap(err, "could not parse expression"))
+	if r.Expr.Value == "" {
+		nodes = append(nodes, WrappedError{
+			err:  errors.Errorf("field 'expr' must be set in rule"),
+			node: &r.Expr,
+		})
+	} else if _, err := promql.ParseExpr(r.Expr.Value); err != nil {
+		nodes = append(nodes, WrappedError{
+			err:  errors.Wrapf(err, "could not parse expression"),
+			node: &r.Expr,
+		})
 	}
-	if r.Record != "" {
+	if r.Record.Value != "" {
 		if len(r.Annotations) > 0 {
-			errs = append(errs, errors.Errorf("invalid field 'annotations' in recording rule"))
+			nodes = append(nodes, WrappedError{
+				err:  errors.Errorf("invalid field 'annotations' in recording rule"),
+				node: &r.Record,
+			})
 		}
 		if r.For != 0 {
-			errs = append(errs, errors.Errorf("invalid field 'for' in recording rule"))
+			nodes = append(nodes, WrappedError{
+				err:  errors.Errorf("invalid field 'for' in recording rule"),
+				node: &r.Record,
+			})
 		}
-		if !model.IsValidMetricName(model.LabelValue(r.Record)) {
-			errs = append(errs, errors.Errorf("invalid recording rule name: %s", r.Record))
+		if !model.IsValidMetricName(model.LabelValue(r.Record.Value)) {
+			nodes = append(nodes, WrappedError{
+				err:  errors.Errorf("invalid recording rule name: %s", r.Record.Value),
+				node: &r.Record,
+			})
 		}
 	}
 
 	for k, v := range r.Labels {
 		if !model.LabelName(k).IsValid() {
-			errs = append(errs, errors.Errorf("invalid label name: %s", k))
+			nodes = append(nodes, WrappedError{
+				err: errors.Errorf("invalid label name: %s", k),
+			})
 		}
 
 		if !model.LabelValue(v).IsValid() {
-			errs = append(errs, errors.Errorf("invalid label value: %s", v))
+			nodes = append(nodes, WrappedError{
+				err: errors.Errorf("invalid label value: %s", v),
+			})
 		}
 	}
 
 	for k := range r.Annotations {
 		if !model.LabelName(k).IsValid() {
-			errs = append(errs, errors.Errorf("invalid annotation name: %s", k))
+			nodes = append(nodes, WrappedError{
+				err: errors.Errorf("invalid annotation name: %s", k),
+			})
 		}
 	}
 
-	return append(errs, testTemplateParsing(r)...)
+	for _, err := range testTemplateParsing(r) {
+		nodes = append(nodes, WrappedError{err: err})
+	}
+
+	return
 }
 
 // testTemplateParsing checks if the templates used in labels and annotations
 // of the alerting rules are parsed correctly.
-func testTemplateParsing(rl *Rule) (errs []error) {
-	if rl.Alert == "" {
+func testTemplateParsing(rl *RuleNode) (errs []error) {
+	if rl.Alert.Value == "" {
 		// Not an alerting rule.
 		return errs
 	}
@@ -165,7 +231,7 @@ func testTemplateParsing(rl *Rule) (errs []error) {
 		tmpl := template.NewTemplateExpander(
 			context.TODO(),
 			strings.Join(append(defs, text), ""),
-			"__alert_"+rl.Alert,
+			"__alert_"+rl.Alert.Value,
 			tmplData,
 			model.Time(timestamp.FromTime(time.Now())),
 			nil,
@@ -195,11 +261,16 @@ func testTemplateParsing(rl *Rule) (errs []error) {
 
 // Parse parses and validates a set of rules.
 func Parse(content []byte) (*RuleGroups, []error) {
-	var groups RuleGroups
-	if err := yaml.UnmarshalStrict(content, &groups); err != nil {
+	var (
+		groups RuleGroups
+		node   ruleGroups
+	)
+	err := yaml.Unmarshal(content, &groups)
+	_err := yaml.Unmarshal(content, &node)
+	if err != nil || _err != nil {
 		return nil, []error{err}
 	}
-	return &groups, groups.Validate()
+	return &groups, groups.Validate(node)
 }
 
 // ParseFile reads and parses rules from a file.

rules/manager.go

@@ -931,14 +931,14 @@ func (m *Manager) LoadGroups(
 
 			rules := make([]Rule, 0, len(rg.Rules))
 			for _, r := range rg.Rules {
-				expr, err := promql.ParseExpr(r.Expr)
+				expr, err := promql.ParseExpr(r.Expr.Value)
 				if err != nil {
 					return nil, []error{errors.Wrap(err, fn)}
 				}
 
-				if r.Alert != "" {
+				if r.Alert.Value != "" {
 					rules = append(rules, NewAlertingRule(
-						r.Alert,
+						r.Alert.Value,
 						expr,
 						time.Duration(r.For),
 						labels.FromMap(r.Labels),
@@ -950,7 +950,7 @@ func (m *Manager) LoadGroups(
 					continue
 				}
 				rules = append(rules, NewRecordingRule(
-					r.Record,
+					r.Record.Value,
 					expr,
 					labels.FromMap(r.Labels),
 				))

rules/manager_test.go

@@ -756,14 +756,52 @@ func TestUpdate(t *testing.T) {
 	// Change group rules and reload.
 	for i, g := range rgs.Groups {
 		for j, r := range g.Rules {
-			rgs.Groups[i].Rules[j].Expr = fmt.Sprintf("%s * 0", r.Expr)
+			rgs.Groups[i].Rules[j].Expr.SetString(fmt.Sprintf("%s * 0", r.Expr.Value))
 		}
 	}
 	reloadAndValidate(rgs, t, tmpFile, ruleManager, expected, ogs)
 }
 
+// ruleGroupsTest for running tests over rules.
+type ruleGroupsTest struct {
+	Groups []ruleGroupTest `yaml:"groups"`
+}
+
+// ruleGroupTest forms a testing struct for running tests over rules.
+type ruleGroupTest struct {
+	Name     string         `yaml:"name"`
+	Interval model.Duration `yaml:"interval,omitempty"`
+	Rules    []rulefmt.Rule `yaml:"rules"`
+}
+
+func formatRules(r *rulefmt.RuleGroups) ruleGroupsTest {
+	grps := r.Groups
+	tmp := []ruleGroupTest{}
+	for _, g := range grps {
+		rtmp := []rulefmt.Rule{}
+		for _, r := range g.Rules {
+			rtmp = append(rtmp, rulefmt.Rule{
+				Record:      r.Record.Value,
+				Alert:       r.Alert.Value,
+				Expr:        r.Expr.Value,
+				For:         r.For,
+				Labels:      r.Labels,
+				Annotations: r.Annotations,
+			})
+		}
+		tmp = append(tmp, ruleGroupTest{
+			Name:     g.Name,
+			Interval: g.Interval,
+			Rules:    rtmp,
+		})
+	}
+	return ruleGroupsTest{
+		Groups: tmp,
+	}
+}
+
 func reloadAndValidate(rgs *rulefmt.RuleGroups, t *testing.T, tmpFile *os.File, ruleManager *Manager, expected map[string]labels.Labels, ogs map[string]*Group) {
-	bs, err := yaml.Marshal(rgs)
+	bs, err := yaml.Marshal(formatRules(rgs))
 	testutil.Ok(t, err)
 	tmpFile.Seek(0, 0)
 	_, err = tmpFile.Write(bs)

vendor/gopkg.in/yaml.v3/.travis.yml

+language: go
+
+go:
+    - "1.4.x"
+    - "1.5.x"
+    - "1.6.x"
+    - "1.7.x"
+    - "1.8.x"
+    - "1.9.x"
+    - "1.10.x"
+    - "1.11.x"
+    - "1.12.x"
+    - "1.13.x"
+    - "tip"
+
+go_import_path: gopkg.in/yaml.v3

vendor/gopkg.in/yaml.v3/LICENSE

+
+This project is covered by two different licenses: MIT and Apache.
+
+#### MIT License ####
+
+The following files were ported to Go from C files of libyaml, and thus
+are still covered by their original MIT license, with the additional
+copyright staring in 2011 when the project was ported over:
+
+    apic.go emitterc.go parserc.go readerc.go scannerc.go
+    writerc.go yamlh.go yamlprivateh.go
+
+Copyright (c) 2006-2010 Kirill Simonov
+Copyright (c) 2006-2011 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+### Apache License ###
+
+All the remaining project files are covered by the Apache license:
+
+Copyright (c) 2011-2019 Canonical Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/gopkg.in/yaml.v3/NOTICE

+Copyright 2011-2016 Canonical Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/gopkg.in/yaml.v3/README.md

+# YAML support for the Go language
+
+Introduction
+------------
+
+The yaml package enables Go programs to comfortably encode and decode YAML
+values. It was developed within [Canonical](https://www.canonical.com) as
+part of the [juju](https://juju.ubuntu.com) project, and is based on a
+pure Go port of the well-known [libyaml](http://pyyaml.org/wiki/LibYAML)
+C library to parse and generate YAML data quickly and reliably.
+
+Compatibility
+-------------
+
+The yaml package supports most of YAML 1.2, but preserves some behavior
+from 1.1 for backwards compatibility.
+
+Specifically, as of v3 of the yaml package:
+
+ - YAML 1.1 bools (_yes/no, on/off_) are supported as long as they are being
+   decoded into a typed bool value. Otherwise they behave as a string. Booleans
+   in YAML 1.2 are _true/false_ only.
+ - Octals encode and decode as _0777_ per YAML 1.1, rather than _0o777_
+   as specified in YAML 1.2, because most parsers still use the old format.
+   Octals in the  _0o777_ format are supported though, so new files work.
+ - Does not support base-60 floats. These are gone from YAML 1.2, and were
+   actually never supported by this package as it's clearly a poor choice.
+
+and offers backwards
+compatibility with YAML 1.1 in some cases.
+1.2, including support for
+anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
+implemented, and base-60 floats from YAML 1.1 are purposefully not
+supported since they're a poor design and are gone in YAML 1.2.
+
+Installation and usage
+----------------------
+
+The import path for the package is *gopkg.in/yaml.v3*.
+
+To install it, run:
+
+    go get gopkg.in/yaml.v3
+
+API documentation
+-----------------
+
+If opened in a browser, the import path itself leads to the API documentation:
+
+  - [https://gopkg.in/yaml.v3](https://gopkg.in/yaml.v3)
+
+API stability
+-------------
+
+The package API for yaml v3 will remain stable as described in [gopkg.in](https://gopkg.in).
+
+
+License
+-------
+
+The yaml package is licensed under the MIT and Apache License 2.0 licenses.
+Please see the LICENSE file for details.
+
+
+Example
+-------
+
+```Go
+package main
+
+import (
+        "fmt"
+        "log"
+
+        "gopkg.in/yaml.v3"
+)
+
+var data = `
+a: Easy!
+b:
+  c: 2
+  d: [3, 4]
+`
+
+// Note: struct fields must be public in order for unmarshal to
+// correctly populate the data.
+type T struct {
+        A string
+        B struct {
+                RenamedC int   `yaml:"c"`
+                D        []int `yaml:",flow"`
+        }
+}
+
+func main() {
+        t := T{}
+    
+        err := yaml.Unmarshal([]byte(data), &t)
+        if err != nil {
+                log.Fatalf("error: %v", err)
+        }
+        fmt.Printf("--- t:\n%v\n\n", t)
+    
+        d, err := yaml.Marshal(&t)
+        if err != nil {
+                log.Fatalf("error: %v", err)
+        }
+        fmt.Printf("--- t dump:\n%s\n\n", string(d))
+    
+        m := make(map[interface{}]interface{})
+    
+        err = yaml.Unmarshal([]byte(data), &m)
+        if err != nil {
+                log.Fatalf("error: %v", err)
+        }
+        fmt.Printf("--- m:\n%v\n\n", m)
+    
+        d, err = yaml.Marshal(&m)
+        if err != nil {
+                log.Fatalf("error: %v", err)
+        }
+        fmt.Printf("--- m dump:\n%s\n\n", string(d))
+}
+```
+
+This example will generate the following output:
+
+```
+--- t:
+{Easy! {2 [3 4]}}
+
+--- t dump:
+a: Easy!
+b:
+  c: 2
+  d: [3, 4]
+
+
+--- m:
+map[a:Easy! b:map[c:2 d:[3 4]]]
+
+--- m dump:
+a: Easy!
+b:
+  c: 2
+  d:
+  - 3
+  - 4
+```
+

vendor/gopkg.in/yaml.v3/encode.go

+//
+// Copyright (c) 2011-2019 Canonical Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software