logql

type BinOpOptions ¶

type BinOpOptions struct {
	ReturnBool bool
}

type ConcatLogSelectorExpr ¶

type ConcatLogSelectorExpr struct {
	DownstreamLogSelectorExpr
	// contains filtered or unexported fields
}

ConcatLogSelectorExpr is an expr for concatenating multiple LogSelectorExpr

func (c ConcatLogSelectorExpr) String() string

type ConcatSampleExpr ¶

type ConcatSampleExpr struct {
	DownstreamSampleExpr
	// contains filtered or unexported fields
}

ConcatSampleExpr is an expr for concatenating multiple SampleExpr Contract: The embedded SampleExprs within a linked list of ConcatSampleExprs must be of the same structure. This makes special implementations of SampleExpr.Associative() unnecessary.

func (c ConcatSampleExpr) String() string

type DefaultEvaluator ¶

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

func NewDefaultEvaluator(querier Querier, maxLookBackPeriod time.Duration) *DefaultEvaluator

func (ev *DefaultEvaluator) Iterator(ctx context.Context, expr LogSelectorExpr, q Params) (iter.EntryIterator, error)

func (ev *DefaultEvaluator) StepEvaluator(
	ctx context.Context,
	nextEv SampleEvaluator,
	expr SampleExpr,
	q Params,
) (StepEvaluator, error)

type DownstreamEvaluator ¶

type DownstreamEvaluator struct {
	Downstreamer
	// contains filtered or unexported fields
}

DownstreamEvaluator is an evaluator which handles shard aware AST nodes

func NewDownstreamEvaluator(downstreamer Downstreamer) *DownstreamEvaluator

func (ev DownstreamEvaluator) Downstream(ctx context.Context, queries []DownstreamQuery) ([]Result, error)

func (ev *DownstreamEvaluator) Iterator(
	ctx context.Context,
	expr LogSelectorExpr,
	params Params,
) (iter.EntryIterator, error)

func (ev *DownstreamEvaluator) StepEvaluator(
	ctx context.Context,
	nextEv SampleEvaluator,
	expr SampleExpr,
	params Params,
) (StepEvaluator, error)

type DownstreamLogSelectorExpr ¶

type DownstreamLogSelectorExpr struct {
	LogSelectorExpr
	// contains filtered or unexported fields
}

DownstreamLogSelectorExpr is a LogSelectorExpr which signals downstream computation

func (d DownstreamLogSelectorExpr) String() string

type DownstreamQuery ¶

type DownstreamQuery struct {
	Expr   Expr
	Params Params
	Shards Shards
}

type DownstreamSampleExpr ¶

type DownstreamSampleExpr struct {
	SampleExpr
	// contains filtered or unexported fields
}

DownstreamSampleExpr is a SampleExpr which signals downstream computation

func (d DownstreamSampleExpr) String() string

type Downstreamable ¶

type Downstreamable interface {
	Downstreamer() Downstreamer
}

type Downstreamer ¶

type Downstreamer interface {
	Downstream(context.Context, []DownstreamQuery) ([]Result, error)
}

Downstreamer is an interface for deferring responsibility for query execution. It is decoupled from but consumed by a downStreamEvaluator to dispatch ASTs.

type Engine ¶

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

Engine is the LogQL engine.

func NewEngine(opts EngineOpts, q Querier, l Limits) *Engine

func (ng *Engine) Query(params Params) Query

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.

func (opts *EngineOpts) RegisterFlagsWithPrefix(prefix string, f *flag.FlagSet)

type EntryEvaluator ¶

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

type Evaluator ¶

type Evaluator interface {
	SampleEvaluator
	EntryEvaluator
}

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

type Expr ¶

type Expr interface {
	Shardable() bool // A recursive check on the AST to see if it's shardable.
	fmt.Stringer
	// contains filtered or unexported methods
}

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

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

type Limits ¶

type Limits interface {
	MaxQuerySeries(userID string) int
}

Limits allow the engine to fetch limits for a given users.

type LiteralParams ¶

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

LiteralParams impls Params

func NewLiteralParams(
	qs string,
	start, end time.Time,
	step, interval time.Duration,
	direction logproto.Direction,
	limit uint32,
	shards []string,
) LiteralParams

func (p LiteralParams) Copy() LiteralParams

func (p LiteralParams) Direction() logproto.Direction

func (p LiteralParams) End() time.Time

func (p LiteralParams) Interval() time.Duration

func (p LiteralParams) Limit() uint32

func (p LiteralParams) Query() string

func (p LiteralParams) Shards() []string

func (p LiteralParams) Start() time.Time

func (p LiteralParams) Step() time.Duration

type LogSelectorExpr ¶

type LogSelectorExpr interface {
	Matchers() []*labels.Matcher
	PipelineExpr
	HasFilter() bool
	Expr
}

LogSelectorExpr is a LogQL expression filtering and returning logs.

func AddFilterExpr(expr LogSelectorExpr, ty labels.MatchType, match string) (LogSelectorExpr, error)

func ParseLogSelector(input string) (LogSelectorExpr, error)

type MatrixStepper ¶

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

MatrixStepper exposes a promql.Matrix as a StepEvaluator. Ensure that the resulting StepEvaluator maintains the same shape that the parameters expect. For example, it's possible that a downstream query returns matches no log streams and thus returns an empty matrix. However, we still need to ensure that it can be merged effectively with another leg that may match series. Therefore, we determine our steps from the parameters and not the underlying Matrix.

func NewMatrixStepper(start, end time.Time, step time.Duration, m promql.Matrix) *MatrixStepper

func (m *MatrixStepper) Close() error

func (m *MatrixStepper) Error() error

func (m *MatrixStepper) Next() (bool, int64, promql.Vector)

type MockDownstreamer ¶

type MockDownstreamer struct {
	*Engine
}

func (m MockDownstreamer) Downstream(ctx context.Context, queries []DownstreamQuery) ([]Result, error)

func (m MockDownstreamer) Downstreamer() Downstreamer

type MockQuerier ¶

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

Shard aware mock querier

func NewMockQuerier(shards int, streams []logproto.Stream) MockQuerier

func (q MockQuerier) SelectLogs(ctx context.Context, req SelectLogParams) (iter.EntryIterator, error)

func (q MockQuerier) SelectSamples(ctx context.Context, req SelectSampleParams) (iter.SampleIterator, error)

type MultiStageExpr ¶

type MultiStageExpr []StageExpr

MultiStageExpr is multiple stages which implement a PipelineExpr.

func (m MultiStageExpr) Pipeline() (log.Pipeline, error)

func (m MultiStageExpr) String() string

type Params ¶

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

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 (p ParseError) Error() string

func (p ParseError) Is(target error) bool

type Pipeline ¶

type Pipeline = log.Pipeline

Type alias for backward compatibility

type PipelineExpr ¶

type PipelineExpr interface {
	Pipeline() (Pipeline, error)
	Expr
}

PipelineExpr is an expression defining a log pipeline.

type Querier ¶

type Querier interface {
	SelectLogs(context.Context, SelectLogParams) (iter.EntryIterator, error)
	SelectSamples(context.Context, SelectSampleParams) (iter.SampleIterator, error)
}

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

type Query ¶

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

Query is a LogQL query to be executed.

type QueryParams ¶

type QueryParams interface {
	LogSelector() (LogSelectorExpr, error)
	GetStart() time.Time
	GetEnd() time.Time
	GetShards() []string
}

type QueryRangeType ¶

type QueryRangeType string

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

func GetRangeType(q Params) QueryRangeType

type RangeVectorAggregator ¶

type RangeVectorAggregator func([]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
	Error() 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_parser.Value
	Statistics stats.Result
}

Result is the result of a query execution.

type SampleEvaluator ¶

type SampleEvaluator interface {
	// StepEvaluator returns a StepEvaluator for a given SampleExpr. It's explicitly passed another StepEvaluator// in order to enable arbitrary computation of embedded expressions. This allows more modular & extensible
	// StepEvaluator implementations which can be composed.
	StepEvaluator(ctx context.Context, nextEvaluator SampleEvaluator, expr SampleExpr, p Params) (StepEvaluator, error)
}

type SampleEvaluatorFunc ¶

type SampleEvaluatorFunc func(ctx context.Context, nextEvaluator SampleEvaluator, expr SampleExpr, p Params) (StepEvaluator, error)

func (s SampleEvaluatorFunc) StepEvaluator(ctx context.Context, nextEvaluator SampleEvaluator, expr SampleExpr, p Params) (StepEvaluator, error)

type SampleExpr ¶

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

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

func ParseSampleExpr(input string) (SampleExpr, error)

type SampleExtractor ¶

type SampleExtractor = log.SampleExtractor

type SelectLogParams ¶

type SelectLogParams struct {
	*logproto.QueryRequest
}

SelectParams specifies parameters passed to data selections.

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

type SelectSampleParams ¶

type SelectSampleParams struct {
	*logproto.SampleQueryRequest
}

func (s SelectSampleParams) Expr() (SampleExpr, error)

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

type ShardMapper ¶

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

func NewShardMapper(shards int, metrics *ShardingMetrics) (ShardMapper, error)

func (m ShardMapper) Map(expr Expr, r *shardRecorder) (Expr, error)

func (m ShardMapper) Parse(query string) (noop bool, expr Expr, err error)

type ShardedEngine ¶

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

ShardedEngine is an Engine implementation that can split queries into more parallelizable forms via querying the underlying backend shards individually and reaggregating them.

func NewShardedEngine(opts EngineOpts, downstreamable Downstreamable, metrics *ShardingMetrics, limits Limits) *ShardedEngine

func (ng *ShardedEngine) Query(p Params, mapped Expr) Query

type ShardingMetrics ¶

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

ShardingMetrics is the metrics wrapper used in shard mapping

func NewShardingMetrics(registerer prometheus.Registerer) *ShardingMetrics

type Shards ¶

type Shards []astmapper.ShardAnnotation

func ParseShards(strs []string) (Shards, error)

func (xs Shards) Encode() (encoded []string)

type StageExpr ¶

type StageExpr interface {
	Stage() (log.Stage, error)
	Expr
}

StageExpr is an expression defining a single step into a log pipeline

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
	// Reports any error
	Error() error
}

StepEvaluator evaluate a single step of a query.

func ConcatEvaluator(evaluators []StepEvaluator) (StepEvaluator, error)

func ResultStepEvaluator(res Result, params Params) (StepEvaluator, error)

type Streams ¶

type Streams []logproto.Stream

Streams is promql.Value

func (streams Streams) Len() int

func (streams Streams) Less(i, j int) bool

func (Streams) String() string

func (streams Streams) Swap(i, j int)

func (Streams) Type() promql_parser.ValueType