promql

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(opts EngineOpts) *Engine

func (ng *Engine) GetTimeRangesForSelector(s *parser.EvalStmt, n *parser.VectorSelector, path []parser.Node, evalRange time.Duration) (int64, int64)

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

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

type EngineOpts ¶

type EngineOpts struct {
	Timeout time.Duration
	// LookbackDelta determines the time since the last sample after which a time
	// series is considered stale.
	LookbackDelta time.Duration

	// NoStepSubqueryIntervalFn is the default evaluation interval of
	// a subquery in milliseconds if no step in range vector was specified `[30m:<step>]`.
	NoStepSubqueryIntervalFn func(rangeMillis int64) int64

	// EnableAtModifier if true enables @ modifier. Disabled otherwise. This
	// is supposed to be enabled for regular PromQL (as of Prometheus v2.33)
	// but the option to disable it is still provided here for those using
	// the Engine outside of Prometheus.
	EnableAtModifier bool

	// EnableNegativeOffset if true enables negative (-) offset
	// values. Disabled otherwise. This is supposed to be enabled for
	// regular PromQL (as of Prometheus v2.33) but the option to disable it
	// is still provided here for those using the Engine outside of
	// Prometheus.
	EnableNegativeOffset bool
}

EngineOpts contains configuration options used when creating a new 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 ¶

type ErrStorage struct{ Err error }

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

func (e ErrStorage) Error() string

type ErrTooManySamples ¶

type ErrTooManySamples string

ErrTooManySamples is returned if a query would load more than the maximum allowed samples into memory.

func (e ErrTooManySamples) Error() string

type EvalNodeHelper ¶

type EvalNodeHelper struct {
	// Evaluation timestamp.
	Ts int64
	// Vector that can be used for output.
	Out Vector

	// Caches.
	// DropMetricName and label_*.
	Dmn map[uint64]labels.Labels
	// contains filtered or unexported fields
}

EvalNodeHelper stores extra information and caches for evaluating a single node across steps.

func (enh *EvalNodeHelper) DropMetricName(l labels.Labels) labels.Labels

type EvalSeriesHelper ¶

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

EvalSeriesHelper stores extra information about a series.

type FunctionCall ¶

type FunctionCall func(vals []parser.Value, args parser.Expressions, enh *EvalNodeHelper) Vector

FunctionCall is the type of a PromQL function implementation

vals is a list of the evaluated arguments for the function call.

For range vectors it will be a Matrix with one series, instant vectors a
Vector, scalars a Vector with one series whose value is the scalar
value,and nil for strings.

args are the original arguments to the function, where you can access

matrixSelectors, vectorSelectors, and StringLiterals.

enh.Out is a pre-allocated empty vector that you may use to accumulate

output before returning it. The vectors in vals should not be returned.a

Range vector functions need only return a vector with the right value,

the metric and timestamp are not needed.

Instant vector functions need only return a vector with the right values and

metrics, the timestamp are not needed.

Scalar results should be returned as the value of a sample in a Vector.

type Matrix ¶

type Matrix []Series

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

func (m Matrix) ContainsSameLabelset() bool

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 (m Matrix) TotalSamples() int

func (Matrix) Type() parser.ValueType

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 Querier ¶

type Querier interface {
	// Select returns a set of series that matches the given label matchers.
	// Caller can specify if it requires returned series to be sorted. Prefer not requiring sorting for better performance.
	// It allows passing hints that can help in optimising select, but it's up to implementation how this is used if used at all.
	Select(node parser.Node, hints *storage.SelectHints, matchers ...*labels.Matcher) (parser.Node, []storage.Series)

	// Close releases the resources of the Querier.
	Close()
}

Querier provides querying access over time series data of a fixed time range.

type Query ¶

type Query interface {
	// Exec processes the query. Can only be called once.
	Exec(ctx context.Context) *Result
	// Close recovers memory used by the query result.
	Close()
	// Statement returns the parsed statement of the query.
	Statement() parser.Statement
	// Cancel signals that a running query execution should be aborted.
	Cancel()
	// String returns the original query string.
	String() string
}

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

type Queryable ¶

type Queryable interface {
	// Querier returns a new Querier on the storage.
	Querier(ctx context.Context, s *parser.EvalStmt, mint, maxt int64) (Querier, error)
}

A Queryable handles queries against a storage. Use it when you need to have access to all samples without chunk encoding abstraction e.g promQL.

type Result ¶

type Result struct {
	Err      error
	Value    parser.Value
	Warnings storage.Warnings
}

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() parser.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 StorageSeries ¶

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

StorageSeries simulates promql.Series as storage.Series.

func NewStorageSeries(series Series) *StorageSeries

func (ss *StorageSeries) Iterator() chunkenc.Iterator

func (ss *StorageSeries) Labels() labels.Labels

type String ¶

type String struct {
	T int64
	V string
}

String represents a string value.

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

func (s String) String() string

func (String) Type() parser.ValueType

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) ContainsSameLabelset() bool

func (vec Vector) String() string

func (Vector) Type() parser.ValueType