promql

type AggregateExpr ¶

type AggregateExpr struct {
	Op               itemType // The used aggregation operation.
	Expr             Expr     // The Vector expression over which is aggregated.
	Param            Expr     // Parameter used by some aggregators.
	Grouping         []string // The labels by which to group the Vector.
	Without          bool     // Whether to drop the given labels rather than keep them.
	KeepCommonLabels bool     // Whether to keep common labels among result elements.
}

AggregateExpr represents an aggregation operation on a Vector.

func (node *AggregateExpr) String() string

func (e *AggregateExpr) Type() ValueType

type AlertStmt ¶

type AlertStmt struct {
	Name        string
	Expr        Expr
	Duration    time.Duration
	Labels      labels.Labels
	Annotations labels.Labels
}

AlertStmt represents an added alert rule.

func (node *AlertStmt) String() string

type BinaryExpr ¶

type BinaryExpr struct {
	Op       itemType // The operation of the expression.
	LHS, RHS Expr     // The operands on the respective sides of the operator.

	// The matching behavior for the operation if both operands are Vectors.
	// If they are not this field is nil.
	VectorMatching *VectorMatching

	// If a comparison operator, return 0/1 rather than filtering.
	ReturnBool bool
}

BinaryExpr represents a binary expression between two child expressions.

func (node *BinaryExpr) String() string

func (e *BinaryExpr) Type() ValueType

type Call ¶

type Call struct {
	Func *Function   // The function that was called.
	Args Expressions // Arguments used in the call.
}

Call represents a function call.

func (node *Call) String() string

func (e *Call) Type() ValueType

type Engine ¶

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

Engine handles the lifetime of queries from beginning to end. It is connected to a querier.

func NewEngine(queryable Queryable, o *EngineOptions) *Engine

func (ng *Engine) NewInstantQuery(qs string, ts time.Time) (Query, error)

func (ng *Engine) NewRangeQuery(qs string, start, end time.Time, interval time.Duration) (Query, error)

type EngineOptions ¶

type EngineOptions struct {
	MaxConcurrentQueries int
	Timeout              time.Duration
	Logger               log.Logger
}

EngineOptions contains configuration parameters for an Engine.

type ErrQueryCanceled ¶

type ErrQueryCanceled string

ErrQueryCanceled is returned if a query was canceled during processing.

func (e ErrQueryCanceled) Error() string

type ErrQueryTimeout ¶

type ErrQueryTimeout string

ErrQueryTimeout is returned if a query timed out during processing.

func (e ErrQueryTimeout) Error() string

type ErrStorage ¶ added in v1.6.0

type ErrStorage error

ErrStorage is returned if an error was encountered in the storage layer during query handling.

type EvalStmt ¶

type EvalStmt struct {
	Expr Expr // Expression to be evaluated.

	// The time boundaries for the evaluation. If Start equals End an instant
	// is evaluated.
	Start, End time.Time
	// Time between two evaluated instants for the range [Start:End].
	Interval time.Duration
}

EvalStmt holds an expression and information on the range it should be evaluated on.

func (node *EvalStmt) String() string

type Expr ¶

type Expr interface {
	Node

	// Type returns the type the expression evaluates to. It does not perform
	// in-depth checks as this is done at parsing-time.
	Type() ValueType
	// contains filtered or unexported methods
}

Expr is a generic interface for all expression types.

func ParseExpr(input string) (Expr, error)

type Expressions ¶

type Expressions []Expr

Expressions is a list of expression nodes that implements Node.

func (es Expressions) String() (s string)

type Function ¶

type Function struct {
	Name       string
	ArgTypes   []ValueType
	Variadic   int
	ReturnType ValueType
	Call       func(ev *evaluator, args Expressions) Value
}

Function represents a function of the expression language and is used by function nodes.

type Matrix ¶

type Matrix []Series

Matrix is a slice of Seriess that implements sort.Interface and has a String method.

func (m Matrix) Len() int

func (m Matrix) Less(i, j int) bool

func (m Matrix) String() string

func (m Matrix) Swap(i, j int)

func (Matrix) Type() ValueType

type MatrixSelector ¶

type MatrixSelector struct {
	Name          string
	Range         time.Duration
	Offset        time.Duration
	LabelMatchers []*labels.Matcher
	// contains filtered or unexported fields
}

MatrixSelector represents a Matrix selection.

func (node *MatrixSelector) String() string

func (e *MatrixSelector) Type() ValueType

type Node ¶

type Node interface {
	// String representation of the node that returns the given node when parsed
	// as part of a valid query.
	String() string
}

Node is a generic interface for all nodes in an AST.

Whenever numerous nodes are listed such as in a switch-case statement or a chain of function definitions (e.g. String(), expr(), etc.) convention is to list them as follows:

• Statements
• statement types (alphabetical)
• ...
• Expressions
• expression types (alphabetical)
• ...

type NumberLiteral ¶

type NumberLiteral struct {
	Val float64
}

NumberLiteral represents a number.

func (node *NumberLiteral) String() string

func (e *NumberLiteral) Type() ValueType

type ParenExpr ¶

type ParenExpr struct {
	Expr Expr
}

ParenExpr wraps an expression so it cannot be disassembled as a consequence of operator precedence.

func (node *ParenExpr) String() string

func (e *ParenExpr) Type() ValueType

type ParseErr ¶

type ParseErr struct {
	Line, Pos int
	Err       error
}

ParseErr wraps a parsing error with line and position context. If the parsing input was a single line, line will be 0 and omitted from the error string.

func (e *ParseErr) Error() string

type Point ¶

type Point struct {
	T int64
	V float64
}

Point represents a single data point for a given timestamp.

func (p Point) MarshalJSON() ([]byte, error)

func (p Point) String() string

type Pos ¶

type Pos int

Pos is the position in a string.

type Query ¶

type Query interface {
	// Exec processes the query and
	Exec(ctx context.Context) *Result
	// Statement returns the parsed statement of the query.
	Statement() Statement
	// Stats returns statistics about the lifetime of the query.
	Stats() *stats.TimerGroup
	// Cancel signals that a running query execution should be aborted.
	Cancel()
}

A Query is derived from an a raw query string and can be run against an engine it is associated with.

type Queryable ¶ added in v1.3.0

type Queryable interface {
	Querier(mint, maxt int64) (storage.Querier, error)
}

Queryable allows opening a storage querier.

type RecordStmt ¶

type RecordStmt struct {
	Name   string
	Expr   Expr
	Labels labels.Labels
}

RecordStmt represents an added recording rule.

func (node *RecordStmt) String() string

type Result ¶

type Result struct {
	Err   error
	Value Value
}

Result holds the resulting value of an execution or an error if any occurred.

func (r *Result) Matrix() (Matrix, error)

func (r *Result) Scalar() (Scalar, error)

func (r *Result) String() string

func (r *Result) Vector() (Vector, error)

type Sample ¶

type Sample struct {
	Point

	Metric labels.Labels
}

Sample is a single sample belonging to a metric.

func (s Sample) MarshalJSON() ([]byte, error)

func (s Sample) String() string

type Scalar ¶

type Scalar struct {
	T int64
	V float64
}

Scalar is a data point that's explicitly not associated with a metric.

func (s Scalar) MarshalJSON() ([]byte, error)

func (s Scalar) String() string

func (Scalar) Type() ValueType

type Series ¶

type Series struct {
	Metric labels.Labels `json:"metric"`
	Points []Point       `json:"values"`
}

Series is a stream of data points belonging to a metric.

func (s Series) String() string

type Statement ¶

type Statement interface {
	Node
	// contains filtered or unexported methods
}

Statement is a generic interface for all statements.

type Statements ¶

type Statements []Statement

Statements is a list of statement nodes that implements Node.

func ParseStmts(input string) (Statements, error)

func (stmts Statements) String() (s string)

type String ¶

type String struct {
	V string
	T int64
}

String represents a string value.

func (s String) MarshalJSON() ([]byte, error)

func (s String) String() string

func (String) Type() ValueType

type StringLiteral ¶

type StringLiteral struct {
	Val string
}

StringLiteral represents a string.

func (node *StringLiteral) String() string

func (e *StringLiteral) Type() ValueType

type Test ¶

type Test struct {
	testutil.T
	// contains filtered or unexported fields
}

Test is a sequence of read and write commands that are run against a test storage.

func NewTest(t testutil.T, input string) (*Test, error)

func (t *Test) Close()

func (t *Test) Context() context.Context

func (t *Test) QueryEngine() *Engine

func (t *Test) Run() error

func (t *Test) Storage() storage.Storage

type UnaryExpr ¶

type UnaryExpr struct {
	Op   itemType
	Expr Expr
}

UnaryExpr represents a unary operation on another expression. Currently unary operations are only supported for Scalars.

func (node *UnaryExpr) String() string

func (e *UnaryExpr) Type() ValueType

type Value ¶

type Value interface {
	Type() ValueType
	String() string
}

Value is a generic interface for values resulting from a query evaluation.

type ValueType ¶

type ValueType string

ValueType describes a type of a value.

type Vector ¶

type Vector []Sample

Vector is basically only an alias for model.Samples, but the contract is that in a Vector, all Samples have the same timestamp.

func (vec Vector) String() string

func (Vector) Type() ValueType

type VectorMatchCardinality ¶

type VectorMatchCardinality int

VectorMatchCardinality describes the cardinality relationship of two Vectors in a binary operation.

const (
	CardOneToOne VectorMatchCardinality = iota
	CardManyToOne
	CardOneToMany
	CardManyToMany
)

func (vmc VectorMatchCardinality) String() string

type VectorMatching ¶

type VectorMatching struct {
	// The cardinality of the two Vectors.
	Card VectorMatchCardinality
	// MatchingLabels contains the labels which define equality of a pair of
	// elements from the Vectors.
	MatchingLabels []string
	// On includes the given label names from matching,
	// rather than excluding them.
	On bool
	// Include contains additional labels that should be included in
	// the result from the side with the lower cardinality.
	Include []string
}

VectorMatching describes how elements from two Vectors in a binary operation are supposed to be matched.

type VectorSelector ¶

type VectorSelector struct {
	Name          string
	Offset        time.Duration
	LabelMatchers []*labels.Matcher
	// contains filtered or unexported fields
}

VectorSelector represents a Vector selection.

func (node *VectorSelector) String() string

func (e *VectorSelector) Type() ValueType

type Visitor ¶

type Visitor interface {
	Visit(node Node) (w Visitor)
}

Visitor allows visiting a Node and its child nodes. The Visit method is invoked for each node encountered by Walk. If the result visitor w is not nil, Walk visits each of the children of node with the visitor w, followed by a call of w.Visit(nil).