logql

Documentation

Index

• Constants
• func ParseMatchers(input string) ([]*labels.Matcher, error)
• type Engine
  • func NewEngine(opts EngineOpts) *Engine
  • func (ng *Engine) NewInstantQuery(q Querier, qs string, ts time.Time, direction logproto.Direction, limit uint32) Query
  • func (ng *Engine) NewRangeQuery(q Querier, qs string, start, end time.Time, step time.Duration, ...) Query
• type EngineOpts
• type Expr
  • func ParseExpr(input string) (expr Expr, err error)
• type Filter
• type LogSelectorExpr
  • func NewFilterExpr(left LogSelectorExpr, ty labels.MatchType, match string) LogSelectorExpr
  • func ParseLogSelector(input string) (LogSelectorExpr, error)
• 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 RangeVectorAggregator
• type RangeVectorIterator
• type SampleExpr
• type SelectParams
  • func (s SelectParams) LogSelector() (LogSelectorExpr, error)
• type StepEvaluator
• type StepEvaluatorFn
  • func (s StepEvaluatorFn) Next() (bool, int64, promql.Vector)
• type Streams
  • func (Streams) String() string
  • func (Streams) Type() promql.ValueType
• type TagMatcher
  • func (t *TagMatcher) String() string

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"
)

const AVG = 57371

const BOTTOMK = 57377

const BY = 57366

const CLOSE_BRACE = 57356

const CLOSE_BRACKET = 57358

const CLOSE_PARENTHESIS = 57365

const COMMA = 57359

const COUNT = 57374

const COUNT_OVER_TIME = 57368

const DOT = 57360

const DURATION = 57348

const EQ = 57351

const IDENTIFIER = 57346

const LABELS = 57350

const MATCHERS = 57349

const MAX = 57372

const MIN = 57373

const NEQ = 57352

const NRE = 57354

const OPEN_BRACE = 57355

const OPEN_BRACKET = 57357

const OPEN_PARENTHESIS = 57364

const PIPE_EXACT = 57362

const PIPE_MATCH = 57361

const RATE = 57369

const RE = 57353

const SLASH = 57363

const STDDEV = 57375

const STDVAR = 57376

const STRING = 57347

const SUM = 57370

const TOPK = 57378

const ValueTypeStreams = "streams"

ValueTypeStreams promql.ValueType for log streams

const WITHOUT = 57367

Functions

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.

Types

type Engine

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

Engine is the LogQL engine.

func NewEngine

func NewEngine(opts EngineOpts) *Engine

NewEngine creates a new LogQL engine.

func (*Engine) NewInstantQuery

func (ng *Engine) NewInstantQuery(
	q Querier,
	qs string,
	ts time.Time,
	direction logproto.Direction, limit uint32) Query

NewInstantQuery creates a new LogQL instant query.

func (*Engine) NewRangeQuery

func (ng *Engine) NewRangeQuery(
	q Querier,
	qs string,
	start, end time.Time, step time.Duration,
	direction logproto.Direction, limit uint32) Query

NewRangeQuery creates a new LogQL range query.

type EngineOpts

type EngineOpts struct {
	// Timeout for queries execution
	Timeout time.Duration `yaml:"timeout"`
	// MaxLookBackPeriod is the maximun 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 Expr

type Expr interface{}

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 Filter

type Filter func(line []byte) bool

Filter is a function to filter logs.

type LogSelectorExpr

type LogSelectorExpr interface {
	Tags() ([]*TagMatcher, []Filter)
	Filter() (Filter, error)
	Matchers() []*labels.Matcher
	fmt.Stringer
}

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 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) (promql.Value, error)
}

Query is a LogQL query to be executed.

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 SampleExpr

type SampleExpr interface {
	// Selector is the LogQL selector to apply when retrieving logs.
	Selector() LogSelectorExpr
	// Evaluator returns a `StepEvaluator` that can evaluate the expression step by step
	Evaluator() StepEvaluator
	// Close all resources used.
	Close() error
}

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 {
	Next() (bool, int64, promql.Vector)
}

StepEvaluator evaluate a single step of a query.

type StepEvaluatorFn

type StepEvaluatorFn func() (bool, int64, promql.Vector)

StepEvaluatorFn is a function to chain multiple `StepEvaluator`.

func (StepEvaluatorFn) Next

func (s StepEvaluatorFn) Next() (bool, int64, promql.Vector)

Next implements `StepEvaluator`

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`

type TagMatcher

type TagMatcher struct {
	Name  string
	Value string
}

Tag represents a high-cardinality KV label. It does not participate the computation of the streamID, so it will not affect the granularity of the aggregation of chunks.

Tag will store a different index entry, it points to the chunk which contains the log line which has the tag.

When performing a query, tag will be used to determine which chunk to look at, and it will return a Filter func just like any other Filter. And you should use it to filter the lines within that chunk.

func (*TagMatcher) String

func (t *TagMatcher) String() string