logql

Documentation

Index

• Constants
• func IsLogicalBinOp(op string) bool
• func IsParseError(err error) bool
• func ParseMatchers(input string) ([]*labels.Matcher, error)
• func PopulateMatrixFromScalar(data promql.Scalar, params LiteralParams) promql.Matrix
• func QueryType(query string) (string, error)
• func RecordMetrics(ctx context.Context, p Params, status string, stats stats.Result)
• type Engine
  • func NewEngine(opts EngineOpts, q Querier) Engine
• type EngineOpts
• type Evaluator
• type Expr
  • func ParseExpr(input string) (expr Expr, err error)
• type LineFilter
• type LineFilterFunc
  • func (f LineFilterFunc) Filter(line []byte) bool
• type LiteralParams
  • func (p LiteralParams) Direction() logproto.Direction
  • func (p LiteralParams) End() time.Time
  • func (p LiteralParams) Limit() uint32
  • func (p LiteralParams) Query() string
  • func (p LiteralParams) Start() time.Time
  • func (p LiteralParams) Step() time.Duration
• type LogSelectorExpr
  • func NewFilterExpr(left LogSelectorExpr, ty labels.MatchType, match string) LogSelectorExpr
  • func ParseLogSelector(input string) (LogSelectorExpr, error)
• type Params
• type ParseError
  • func (p ParseError) Error() string
• type Querier
• type QuerierFunc
  • func (q QuerierFunc) Select(ctx context.Context, p SelectParams) (iter.EntryIterator, error)
• type Query
• type QueryRangeType
  • func GetRangeType(q Params) QueryRangeType
• type RangeVectorAggregator
• type RangeVectorIterator
• type Result
• type SampleExpr
• type SelectParams
  • func (s SelectParams) LogSelector() (LogSelectorExpr, error)
• type StepEvaluator
• type Streams
  • func (Streams) String() string
  • func (Streams) Type() promql.ValueType

Constants

const (
	OpTypeSum           = "sum"
	OpTypeAvg           = "avg"
	OpTypeMax           = "max"
	OpTypeMin           = "min"
	OpTypeCount         = "count"
	OpTypeStddev        = "stddev"
	OpTypeStdvar        = "stdvar"
	OpTypeBottomK       = "bottomk"
	OpTypeTopK          = "topk"
	OpTypeCountOverTime = "count_over_time"
	OpTypeRate          = "rate"

	// binops - logical/set
	OpTypeOr     = "or"
	OpTypeAnd    = "and"
	OpTypeUnless = "unless"

	// binops - operations
	OpTypeAdd = "+"
	OpTypeSub = "-"
	OpTypeMul = "*"
	OpTypeDiv = "/"
	OpTypeMod = "%"
	OpTypePow = "^"
)

const (
	QueryTypeMetric  = "metric"
	QueryTypeFilter  = "filter"
	QueryTypeLimited = "limited"
)

const ADD = 57382

const AND = 57380

const AVG = 57371

const BOTTOMK = 57377

const BY = 57366

const CLOSE_BRACE = 57357

const CLOSE_BRACKET = 57359

const CLOSE_PARENTHESIS = 57365

const COMMA = 57360

const COUNT = 57374

const COUNT_OVER_TIME = 57368

const DIV = 57385

const DOT = 57361

const DURATION = 57349

const EQ = 57352

const IDENTIFIER = 57346

const LABELS = 57351

const MATCHERS = 57350

const MAX = 57372

const MIN = 57373

const MOD = 57386

const MUL = 57384

const NEQ = 57353

const NRE = 57355

const NUMBER = 57348

const OPEN_BRACE = 57356

const OPEN_BRACKET = 57358

const OPEN_PARENTHESIS = 57364

const OR = 57379

const PIPE_EXACT = 57363

const PIPE_MATCH = 57362

const POW = 57387

const RATE = 57369

const RE = 57354

const STDDEV = 57375

const STDVAR = 57376

const STRING = 57347

const SUB = 57383

const SUM = 57370

const TOPK = 57378

const UNLESS = 57381

const ValueTypeStreams = "streams"

ValueTypeStreams promql.ValueType for log streams

const WITHOUT = 57367

Functions

func IsLogicalBinOp

func IsLogicalBinOp(op string) bool

IsLogicalBinOp tests whether an operation is a logical/set binary operation

func IsParseError

func IsParseError(err error) bool

IsParseError returns true if the err is a ast parsing error.

func ParseMatchers

func ParseMatchers(input string) ([]*labels.Matcher, error)

ParseMatchers parses a string and returns labels matchers, if the expression contains anything else it will return an error.

func PopulateMatrixFromScalar

func PopulateMatrixFromScalar(data promql.Scalar, params LiteralParams) promql.Matrix

func QueryType

func QueryType(query string) (string, error)

func RecordMetrics

func RecordMetrics(ctx context.Context, p Params, status string, stats stats.Result)

Types

type Engine

type Engine interface {
	NewRangeQuery(qs string, start, end time.Time, step time.Duration, direction logproto.Direction, limit uint32) Query
	NewInstantQuery(qs string, ts time.Time, direction logproto.Direction, limit uint32) Query
}

Engine interface used to construct queries

func NewEngine

func NewEngine(opts EngineOpts, q Querier) Engine

NewEngine creates a new LogQL engine.

type EngineOpts

type EngineOpts struct {
	// Timeout for queries execution
	Timeout time.Duration `yaml:"timeout"`
	// MaxLookBackPeriod is the maximum amount of time to look back for log lines.
	// only used for instant log queries.
	MaxLookBackPeriod time.Duration `yaml:"max_look_back_period"`
}

EngineOpts is the list of options to use with the LogQL query engine.

type Evaluator

type Evaluator interface {
	// Evaluator returns a StepEvaluator for a given SampleExpr
	Evaluator(context.Context, SampleExpr, Params) (StepEvaluator, error)
	// Iterator returns the iter.EntryIterator for a given LogSelectorExpr
	Iterator(context.Context, LogSelectorExpr, Params) (iter.EntryIterator, error)
}

Evaluator is an interface for iterating over data at different nodes in the AST

type Expr

type Expr interface {
	fmt.Stringer
	// contains filtered or unexported methods
}

Expr is the root expression which can be a SampleExpr or LogSelectorExpr

func ParseExpr

func ParseExpr(input string) (expr Expr, err error)

ParseExpr parses a string and returns an Expr.

type LineFilter

type LineFilter interface {
	Filter(line []byte) bool
}

LineFilter is a interface to filter log lines.

type LineFilterFunc

type LineFilterFunc func(line []byte) bool

LineFilterFunc is a syntax sugar for creating line filter from a function

func (LineFilterFunc) Filter

func (f LineFilterFunc) Filter(line []byte) bool

type LiteralParams

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

LiteralParams impls Params

func (LiteralParams) Direction

func (p LiteralParams) Direction() logproto.Direction

Direction impls Params

func (LiteralParams) End

func (p LiteralParams) End() time.Time

End impls Params

func (LiteralParams) Limit

func (p LiteralParams) Limit() uint32

Limit impls Params

func (LiteralParams) Query

func (p LiteralParams) Query() string

String impls Params

func (LiteralParams) Start

func (p LiteralParams) Start() time.Time

Start impls Params

func (LiteralParams) Step

func (p LiteralParams) Step() time.Duration

Step impls Params

type LogSelectorExpr

type LogSelectorExpr interface {
	Filter() (LineFilter, error)
	Matchers() []*labels.Matcher
	Expr
}

LogSelectorExpr is a LogQL expression filtering and returning logs.

func NewFilterExpr

func NewFilterExpr(left LogSelectorExpr, ty labels.MatchType, match string) LogSelectorExpr

NewFilterExpr wraps an existing Expr with a next filter expression.

func ParseLogSelector

func ParseLogSelector(input string) (LogSelectorExpr, error)

ParseLogSelector parses a log selector expression `{app="foo"} |= "filter"`

type Params

type Params interface {
	Query() string
	Start() time.Time
	End() time.Time
	Step() time.Duration
	Limit() uint32
	Direction() logproto.Direction
}

Params details the parameters associated with a loki request

type ParseError

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

ParseError is what is returned when we failed to parse.

func (ParseError) Error

func (p ParseError) Error() string

type Querier

type Querier interface {
	Select(context.Context, SelectParams) (iter.EntryIterator, error)
}

Querier allows a LogQL expression to fetch an EntryIterator for a set of matchers and filters

type QuerierFunc

type QuerierFunc func(context.Context, SelectParams) (iter.EntryIterator, error)

QuerierFunc implements Querier.

func (QuerierFunc) Select

func (q QuerierFunc) Select(ctx context.Context, p SelectParams) (iter.EntryIterator, error)

Select implements Querier.

type Query

type Query interface {
	// Exec processes the query.
	Exec(ctx context.Context) (Result, error)
}

Query is a LogQL query to be executed.

type QueryRangeType

type QueryRangeType string

var (
	InstantType QueryRangeType = "instant"
	RangeType   QueryRangeType = "range"
)

func GetRangeType

func GetRangeType(q Params) QueryRangeType

GetRangeType returns whether a query is an instant query or range query

type RangeVectorAggregator

type RangeVectorAggregator func(int64, []promql.Point) float64

RangeVectorAggregator aggregates samples for a given range of samples. It receives the current milliseconds timestamp and the list of point within the range.

type RangeVectorIterator

type RangeVectorIterator interface {
	Next() bool
	At(aggregator RangeVectorAggregator) (int64, promql.Vector)
	Close() error
}

RangeVectorIterator iterates through a range of samples. To fetch the current vector use `At` with a `RangeVectorAggregator`.

type Result

type Result struct {
	Data       promql.Value
	Statistics stats.Result
}

Result is the result of a query execution.

type SampleExpr

type SampleExpr interface {
	// Selector is the LogQL selector to apply when retrieving logs.
	Selector() LogSelectorExpr
	Expr
}

SampleExpr is a LogQL expression filtering logs and returning metric samples.

type SelectParams

type SelectParams struct {
	*logproto.QueryRequest
}

SelectParams specifies parameters passed to data selections.

func (SelectParams) LogSelector

func (s SelectParams) LogSelector() (LogSelectorExpr, error)

LogSelector returns the LogSelectorExpr from the SelectParams. The `LogSelectorExpr` can then returns all matchers and filters to use for that request.

type StepEvaluator

type StepEvaluator interface {
	// while Next returns a promql.Value, the only acceptable types are Scalar and Vector.
	Next() (bool, int64, promql.Vector)
	// Close all resources used.
	Close() error
}

StepEvaluator evaluate a single step of a query.

type Streams

type Streams []*logproto.Stream

Streams is promql.Value

func (Streams) String

func (Streams) String() string

String implements `promql.Value`

func (Streams) Type

func (Streams) Type() promql.ValueType

Type implements `promql.Value`