parser

Documentation

Index

• Variables
• type AlertingRule
  • func (ar *AlertingRule) IsIdentical(b *AlertingRule) bool
• type Content
  • func ReadContent(r io.Reader) (out Content, fileComments []comments.Comment, err error)
• type LineRange
  • func (lr LineRange) Expand() []int
  • func (lr LineRange) String() string
• type ParseError
  • func (pe ParseError) Error() string
• type Parser
  • func NewParser(isStrict bool) Parser
  • func (p Parser) Parse(content []byte) (rules []Rule, err error)
• type PromQLExpr
  • func (pqle PromQLExpr) IsIdentical(b PromQLExpr) bool
• type PromQLNode
  • func DecodeExpr(expr string) (*PromQLNode, error)
  • func WalkDownExpr[T promParser.Node](node *PromQLNode) (nodes []*PromQLNode)
  • func WalkUpExpr[T promParser.Node](node *PromQLNode) (nodes []*PromQLNode)
  • func WalkUpParent[T promParser.Node](node *PromQLNode) (nodes []*PromQLNode)
  • func (pn PromQLNode) MarshalJSON() ([]byte, error)
• type RecordingRule
  • func (rr *RecordingRule) IsIdentical(b *RecordingRule) bool
• type Result
• type Rule
  • func (r Rule) Expr() PromQLExpr
  • func (r Rule) IsIdentical(b Rule) bool
  • func (r Rule) IsSame(nr Rule) bool
  • func (r Rule) Name() string
  • func (r Rule) Type() RuleType
• type RuleType
• type YamlKeyValue
• type YamlMap
  • func (ym YamlMap) GetValue(key string) *YamlNode
  • func (ym *YamlMap) IsIdentical(b *YamlMap) bool
• type YamlNode
  • func (yn *YamlNode) IsIdentical(b *YamlNode) bool

Variables

var ErrRuleCommentOnFile = errors.New("this comment is only valid when attached to a rule")

Types

type AlertingRule

type AlertingRule struct {
	Expr          PromQLExpr
	For           *YamlNode
	KeepFiringFor *YamlNode
	Labels        *YamlMap
	Annotations   *YamlMap
	Alert         YamlNode
}

func (*AlertingRule) IsIdentical

func (ar *AlertingRule) IsIdentical(b *AlertingRule) bool

type Content

type Content struct {
	Body       []byte
	TotalLines int
	IgnoreLine int
	Ignored    bool
}

func ReadContent

func ReadContent(r io.Reader) (out Content, fileComments []comments.Comment, err error)

type LineRange

type LineRange struct {
	First int
	Last  int
}

func (LineRange) Expand

func (lr LineRange) Expand() []int

func (LineRange) String

func (lr LineRange) String() string

type ParseError

type ParseError struct {
	Err     error
	Details string
	Line    int
}

Use insread of StrictError.

func (ParseError) Error

func (pe ParseError) Error() string

type Parser

type Parser struct {
	// contains filtered or unexported fields
}

func NewParser

func NewParser(isStrict bool) Parser

func (Parser) Parse

func (p Parser) Parse(content []byte) (rules []Rule, err error)

type PromQLExpr

type PromQLExpr struct {
	Value       *YamlNode
	SyntaxError error
	Query       *PromQLNode
}

func (PromQLExpr) IsIdentical

func (pqle PromQLExpr) IsIdentical(b PromQLExpr) bool

type PromQLNode

type PromQLNode struct {
	Parent   *PromQLNode
	Expr     promParser.Node
	Children []*PromQLNode
}

PromQLNode is used to turn the parsed PromQL query expression into a tree. This allows us to walk the tree up & down and look for either parents or children of specific type. Which is useful if you, for example, want to check if all vector selectors are wrapped inside function calls etc.

func DecodeExpr

func DecodeExpr(expr string) (*PromQLNode, error)

func WalkDownExpr

func WalkDownExpr[T promParser.Node](node *PromQLNode) (nodes []*PromQLNode)

WalkDownExpr works just like WalkUpExpr but it walks the tree down, visiting all children. It also starts by checking the node passed to it before walking down the tree.

func WalkUpExpr

func WalkUpExpr[T promParser.Node](node *PromQLNode) (nodes []*PromQLNode)

WalkUpExpr allows to iterate a promQLNode node looking for parents of specific type. Prometheus parser returns interfaces which makes it more difficult to figure out what kind of node we're dealing with, hence this helper takes a type parameter it tries to cast. It starts by checking the node passed to it and then walks up by visiting all parent nodes.

func WalkUpParent

func WalkUpParent[T promParser.Node](node *PromQLNode) (nodes []*PromQLNode)

WalkUpParent works like WalkUpExpr but checks the parent (if present) instead of the node itself. It returns the nodes where the parent is of given type.

func (PromQLNode) MarshalJSON

func (pn PromQLNode) MarshalJSON() ([]byte, error)

type RecordingRule

type RecordingRule struct {
	Expr   PromQLExpr
	Labels *YamlMap
	Record YamlNode
}

func (*RecordingRule) IsIdentical

func (rr *RecordingRule) IsIdentical(b *RecordingRule) bool

type Result

type Result struct {
	Path    string
	Error   error
	Content []byte
	Rules   []Rule
}

type Rule

type Rule struct {
	AlertingRule  *AlertingRule
	RecordingRule *RecordingRule
	Error         ParseError
	Comments      []comments.Comment
	Lines         LineRange
}

func (Rule) Expr

func (r Rule) Expr() PromQLExpr

func (Rule) IsIdentical

func (r Rule) IsIdentical(b Rule) bool

func (Rule) IsSame

func (r Rule) IsSame(nr Rule) bool

func (Rule) Name

func (r Rule) Name() string

func (Rule) Type

func (r Rule) Type() RuleType

type RuleType

type RuleType string

const (
	AlertingRuleType  RuleType = "alerting"
	RecordingRuleType RuleType = "recording"
	InvalidRuleType   RuleType = "invalid"
)

type YamlKeyValue

type YamlKeyValue struct {
	Key   *YamlNode
	Value *YamlNode
}

type YamlMap

type YamlMap struct {
	Key   *YamlNode
	Items []*YamlKeyValue
	Lines LineRange
}

func (YamlMap) GetValue

func (ym YamlMap) GetValue(key string) *YamlNode

func (*YamlMap) IsIdentical

func (ym *YamlMap) IsIdentical(b *YamlMap) bool

type YamlNode

type YamlNode struct {
	Value string
	Lines LineRange
}

func (*YamlNode) IsIdentical

func (yn *YamlNode) IsIdentical(b *YamlNode) bool