logql

package

Go to main page

Versions in this module

v3

v3.3.1

Dec 4, 2024

v3.3.0

Nov 19, 2024

Changes in this version

+ const ConCurrency

+ const CountMinSketchVectorType

+ const SupportApproxTopk

+ func JoinCountMinSketchVector(_ bool, r StepResult, stepEvaluator StepEvaluator, params Params) (promql_parser.Value, error)

+ func JoinQuantileSketchVector(next bool, r StepResult, stepEvaluator StepEvaluator, params Params) (promql_parser.Value, error)

+ type CountMinSketchAccumulator struct

+ func (a *CountMinSketchAccumulator) Accumulate(_ context.Context, res logqlmodel.Result, _ int) error

+ func (a *CountMinSketchAccumulator) Result() []logqlmodel.Result

+ type CountMinSketchEvalExpr struct

+ func (e *CountMinSketchEvalExpr) Walk(f syntax.WalkFn)

+ func (e CountMinSketchEvalExpr) String() string

+ type CountMinSketchVector struct

+ F *sketch.CountMinSketch

+ Metrics []labels.Labels

+ T int64

+ func CountMinSketchVectorFromProto(p *logproto.CountMinSketchVector) (CountMinSketchVector, error)

+ func (CountMinSketchVector) QuantileSketchVec() ProbabilisticQuantileVector

+ func (CountMinSketchVector) SampleVector() promql.Vector

+ func (CountMinSketchVector) String() string

+ func (CountMinSketchVector) Type() promql_parser.ValueType

+ func (v *CountMinSketchVector) Merge(right *CountMinSketchVector) (*CountMinSketchVector, error)

+ func (v CountMinSketchVector) CountMinSketchVec() CountMinSketchVector

+ func (v CountMinSketchVector) ToProto() (*logproto.CountMinSketchVector, error)

+ type CountMinSketchVectorStepEvaluator struct

+ func NewCountMinSketchVectorStepEvaluator(vec *CountMinSketchVector) *CountMinSketchVectorStepEvaluator

+ func (*CountMinSketchVectorStepEvaluator) Close() error

+ func (*CountMinSketchVectorStepEvaluator) Error() error

+ func (e *CountMinSketchVectorStepEvaluator) Explain(parent Node)

+ func (e *CountMinSketchVectorStepEvaluator) Next() (bool, int64, StepResult)

type EngineOpts

+ MaxCountMinSketchHeapSize int

+ type HeapCountMinSketchVector struct

+ func NewHeapCountMinSketchVector(ts int64, metricsLength, maxLabels int) HeapCountMinSketchVector

+ func (v *HeapCountMinSketchVector) Add(metric labels.Labels, value float64)

+ func (v *HeapCountMinSketchVector) Pop() any

+ func (v *HeapCountMinSketchVector) Push(x any)

+ func (v HeapCountMinSketchVector) Len() int

+ func (v HeapCountMinSketchVector) Less(i, j int) bool

+ func (v HeapCountMinSketchVector) Swap(i, j int)

type ProbabilisticQuantileVector

+ func (ProbabilisticQuantileVector) CountMinSketchVec() CountMinSketchVector

type SampleVector

+ func (SampleVector) CountMinSketchVec() CountMinSketchVector

type StepResult

+ CountMinSketchVec func() CountMinSketchVector

v3.2.2

Dec 4, 2024

v3.2.1

Oct 17, 2024

v3.2.0

Sep 18, 2024

v3.1.2

Oct 17, 2024

v3.1.1

Aug 8, 2024

v3.1.0

Jul 2, 2024

Changes in this version

+ const ShardFirstOverTime

+ const ShardLastOverTime

+ type EmptyEvaluator struct

+ func (EmptyEvaluator[SampleVector]) Explain(parent Node)

+ func (EmptyEvaluator[_]) Close() error

+ func (EmptyEvaluator[_]) Error() error

+ func (e EmptyEvaluator[_]) Next() (ok bool, ts int64, r StepResult)

type LiteralParams

+ func NewLiteralParamsWithCaching(qs string, start, end time.Time, step, interval time.Duration, ...) (LiteralParams, error)

+ func (p LiteralParams) CachingOptions() resultscache.CachingOptions

+ func (p LiteralParams) GetStoreChunks() *logproto.ChunkRefGroup

+ type MergeFirstOverTimeExpr struct

+ func (e *MergeFirstOverTimeExpr) Walk(f syntax.WalkFn)

+ func (e MergeFirstOverTimeExpr) String() string

+ type MergeLastOverTimeExpr struct

+ func (e *MergeLastOverTimeExpr) Walk(f syntax.WalkFn)

+ func (e MergeLastOverTimeExpr) String() string

type Params

+ func ParamOverridesFromShard(base Params, shard *ShardWithChunkRefs) (result Params)

+ CachingOptions func() resultscache.CachingOptions

+ GetStoreChunks func() *logproto.ChunkRefGroup

+ type ParamsWithChunkOverrides struct

+ StoreChunksOverride *logproto.ChunkRefGroup

+ func (p ParamsWithChunkOverrides) GetStoreChunks() *logproto.ChunkRefGroup

type SelectLogParams

+ func (s SelectLogParams) WithStoreChunks(chunkRefGroup *logproto.ChunkRefGroup) SelectLogParams

type SelectSampleParams

+ func (s SelectSampleParams) WithStoreChunks(chunkRefGroup *logproto.ChunkRefGroup) SelectSampleParams

type Shard

+ func (s Shard) Bind(chunks *logproto.ChunkRefGroup) *ShardWithChunkRefs

+ type ShardWithChunkRefs struct

type StepEvaluator

+ func NewMergeFirstOverTimeStepEvaluator(params Params, m []promql.Matrix) StepEvaluator

+ func NewMergeLastOverTimeStepEvaluator(params Params, m []promql.Matrix) StepEvaluator

v3.0.1

Aug 9, 2024

v3.0.0

Apr 8, 2024

Changes in this version

+ const DefaultBlockedQueryMessage

+ const FailureKey

+ const MaxChildrenDisplay

+ const MetricsKey

+ const NoopKey

+ const QuantileSketchMatrixType

+ const QueryTypeFilter

+ const QueryTypeLabels

+ const QueryTypeLimited

+ const QueryTypeMetric

+ const QueryTypeSeries

+ const QueryTypeShards

+ const QueryTypeStats

+ const QueryTypeVolume

+ const ShardQuantileOverTime

+ const StreamsKey

+ const SuccessKey

+ var NoLimits = &fakeLimits

+ var QueriesBlocked = promauto.NewCounterVec(prometheus.CounterOpts{ ... }, []string{ ... })

+ var QueryTime = promauto.NewHistogramVec(prometheus.HistogramOpts{ ... }, []string{ ... })

+ func EvaluatorUnsupportedType(expr syntax.Expr, ev EvaluatorFactory) error

+ func MatchForSeriesRequest(xs []string) ([][]*labels.Matcher, error)

+ func MergeQuantileSketchVector(next bool, r StepResult, stepEvaluator StepEvaluator, params Params) (promql_parser.Value, error)

+ func ParseShard(s string) (Shard, ShardVersion, error)

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

+ func PopulateMatrixFromScalar(data promql.Scalar, params Params) promql.Matrix

+ func PrintMatches(matches []string) string

+ func Quantile(q float64, values vector.HeapByMaxValue) float64

+ func QueryType(expr syntax.Expr) (string, error)

+ func RecordDetectedFieldsQueryMetrics(ctx context.Context, log log.Logger, start, end time.Time, query string, ...)

+ func RecordDetectedLabelsQueryMetrics(_ context.Context, _ log.Logger, _ time.Time, _ time.Time, _ string, _ string, ...)

+ func RecordLabelQueryMetrics(ctx context.Context, log log.Logger, start, end time.Time, ...)

+ func RecordRangeAndInstantQueryMetrics(ctx context.Context, log log.Logger, p Params, status string, ...)

+ func RecordSeriesQueryMetrics(ctx context.Context, log log.Logger, start, end time.Time, match []string, ...)

+ func RecordShardsQueryMetrics(ctx context.Context, log log.Logger, start, end time.Time, query string, ...)

+ func RecordStatsQueryMetrics(ctx context.Context, log log.Logger, start, end time.Time, query string, ...)

+ func RecordVolumeQueryMetrics(ctx context.Context, log log.Logger, start, end time.Time, query string, ...)

+ func ResultIterator(res logqlmodel.Result, direction logproto.Direction) (iter.EntryIterator, error)

+ func Sortable(q Params) (bool, error)

+ type AbsentRangeVectorEvaluator struct

+ func (e *AbsentRangeVectorEvaluator) Explain(parent Node)

+ func (r *AbsentRangeVectorEvaluator) Next() (bool, int64, StepResult)

+ func (r AbsentRangeVectorEvaluator) Close() error

+ func (r AbsentRangeVectorEvaluator) Error() error

+ type AccumulatedStreams struct

+ func NewStreamAccumulator(params Params) *AccumulatedStreams

+ func (acc *AccumulatedStreams) Accumulate(_ context.Context, x logqlmodel.Result, _ int) error

+ func (acc *AccumulatedStreams) Find(labels string) (int, bool)

+ func (acc *AccumulatedStreams) Len() int

+ func (acc *AccumulatedStreams) Less(i, j int) bool

+ func (acc *AccumulatedStreams) Pop() any

+ func (acc *AccumulatedStreams) Push(x any)

+ func (acc *AccumulatedStreams) Result() []logqlmodel.Result

+ func (acc *AccumulatedStreams) Swap(i, j int)

+ type Accumulator interface

+ Accumulate func(context.Context, logqlmodel.Result, int) error

+ Result func() []logqlmodel.Result

+ type AvgOverTime struct

+ type BatchRangeVectorAggregator func([]promql.FPoint) float64

+ type BinOpStepEvaluator struct

+ func (e *BinOpStepEvaluator) Close() (lastError error)

+ func (e *BinOpStepEvaluator) Error() error

+ func (e *BinOpStepEvaluator) Explain(parent Node)

+ func (e *BinOpStepEvaluator) Next() (bool, int64, StepResult)

+ type BufferedAccumulator struct

+ func NewBufferedAccumulator(n int) *BufferedAccumulator

+ func (a *BufferedAccumulator) Accumulate(_ context.Context, acc logqlmodel.Result, i int) error

+ func (a *BufferedAccumulator) Result() []logqlmodel.Result

+ type ConcatLogSelectorExpr struct

+ func (c *ConcatLogSelectorExpr) Pretty(level int) string

+ func (c *ConcatLogSelectorExpr) String() string

+ type ConcatSampleExpr struct

+ func (c *ConcatSampleExpr) Pretty(level int) string

+ func (c *ConcatSampleExpr) String() string

+ func (c *ConcatSampleExpr) Walk(f syntax.WalkFn)

+ type ConcatStepEvaluator struct

+ func NewConcatStepEvaluator(evaluators []StepEvaluator) *ConcatStepEvaluator

+ func (e *ConcatStepEvaluator) Close() (lastErr error)

+ func (e *ConcatStepEvaluator) Error() error

+ func (e *ConcatStepEvaluator) Explain(parent Node)

+ func (e *ConcatStepEvaluator) Next() (bool, int64, StepResult)

+ type ConstantShards int

+ func (s ConstantShards) GetStats(_ syntax.Expr) (stats.Stats, error)

+ func (s ConstantShards) ShardingRanges(_ syntax.Expr, _ uint64) ([]logproto.Shard, error)

+ func (s ConstantShards) Shards(_ syntax.Expr) (int, uint64, error)

+ type CountOverTime struct

+ type DefaultEvaluator struct

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

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

+ func (ev *DefaultEvaluator) NewStepEvaluator(ctx context.Context, nextEvFactory SampleEvaluatorFactory, ...) (StepEvaluator, error)

+ type DownstreamEngine struct

+ func NewDownstreamEngine(opts EngineOpts, downstreamable Downstreamable, limits Limits, ...) *DownstreamEngine

+ func (ng *DownstreamEngine) Opts() EngineOpts

+ func (ng *DownstreamEngine) Query(ctx context.Context, p Params) Query

+ type DownstreamEvaluator struct

+ func NewDownstreamEvaluator(downstreamer Downstreamer) *DownstreamEvaluator

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

+ func (ev *DownstreamEvaluator) NewStepEvaluator(ctx context.Context, nextEvFactory SampleEvaluatorFactory, ...) (StepEvaluator, error)

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

+ type DownstreamLogSelectorExpr struct

+ func (d DownstreamLogSelectorExpr) Pretty(level int) string

+ func (d DownstreamLogSelectorExpr) String() string

+ type DownstreamQuery struct

+ Params Params

+ type DownstreamSampleExpr struct

+ func (d DownstreamSampleExpr) Pretty(level int) string

+ func (d DownstreamSampleExpr) String() string

+ func (d DownstreamSampleExpr) Walk(f syntax.WalkFn)

+ type Downstreamable interface

+ Downstreamer func(context.Context) Downstreamer

+ type Downstreamer interface

+ Downstream func(context.Context, []DownstreamQuery, Accumulator) ([]logqlmodel.Result, error)

+ type DynamicBoundsStrategy struct

+ func NewDynamicBoundsStrategy(resolver ShardResolver, targetBytesPerShard uint64) DynamicBoundsStrategy

+ func (s DynamicBoundsStrategy) Resolver() ShardResolver

+ func (s DynamicBoundsStrategy) Shards(expr syntax.Expr) (Shards, uint64, error)

+ type Engine struct

+ func NewEngine(opts EngineOpts, q Querier, l Limits, logger log.Logger) *Engine

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

+ type EngineOpts struct

+ LogExecutingQuery bool

+ MaxLookBackPeriod time.Duration

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

+ type EntryEvaluatorFactory interface

+ NewIterator func(context.Context, syntax.LogSelectorExpr, Params) (iter.EntryIterator, error)

+ type EvaluatorFactory interface

+ type FirstOverTime struct

+ type LabelReplaceEvaluator struct

+ func (e *LabelReplaceEvaluator) Close() error

+ func (e *LabelReplaceEvaluator) Error() error

+ func (e *LabelReplaceEvaluator) Explain(parent Node)

+ func (e *LabelReplaceEvaluator) Next() (bool, int64, StepResult)

+ type LastOverTime struct

+ type Limits interface

+ BlockedQueries func(context.Context, string) []*validation.BlockedQuery

+ MaxQueryRange func(ctx context.Context, userID string) time.Duration

+ MaxQuerySeries func(context.Context, string) int

+ QueryTimeout func(context.Context, string) time.Duration

+ type LiteralParams struct

+ func NewLiteralParams(qs string, start, end time.Time, step, interval time.Duration, ...) (LiteralParams, error)

+ func (p LiteralParams) Copy() LiteralParams

+ func (p LiteralParams) Direction() logproto.Direction

+ func (p LiteralParams) End() time.Time

+ func (p LiteralParams) GetExpression() syntax.Expr

+ func (p LiteralParams) Interval() time.Duration

+ func (p LiteralParams) Limit() uint32

+ func (p LiteralParams) QueryString() string

+ func (p LiteralParams) Shards() []string

+ func (p LiteralParams) Start() time.Time

+ func (p LiteralParams) Step() time.Duration

+ type LiteralStepEvaluator struct

+ func (e *LiteralStepEvaluator) Close() error

+ func (e *LiteralStepEvaluator) Error() error

+ func (e *LiteralStepEvaluator) Explain(parent Node)

+ func (e *LiteralStepEvaluator) Next() (bool, int64, StepResult)

+ type MapperMetrics struct

+ DownstreamFactor prometheus.Histogram

+ DownstreamQueries *prometheus.CounterVec

+ ParsedQueries *prometheus.CounterVec

+ func NewRangeMapperMetrics(registerer prometheus.Registerer) *MapperMetrics

+ func NewShardMapperMetrics(registerer prometheus.Registerer) *MapperMetrics

+ type MapperStats struct

+ func NewMapperStats() *MapperStats

+ func (s *MapperStats) AddSplitQueries(num int)

+ func (s *MapperStats) GetSplitQueries() int

+ type MatrixStepEvaluator struct

+ func NewMatrixStepEvaluator(start, end time.Time, step time.Duration, m promql.Matrix) *MatrixStepEvaluator

+ func (m *MatrixStepEvaluator) Close() error

+ func (m *MatrixStepEvaluator) Error() error

+ func (m *MatrixStepEvaluator) Explain(parent Node)

+ func (m *MatrixStepEvaluator) Next() (bool, int64, StepResult)

+ type MaxOverTime struct

+ type MinOverTime struct

+ type MockDownstreamer struct

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

+ func (m MockDownstreamer) Downstreamer(_ context.Context) Downstreamer

+ type MockQuerier struct

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

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

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

+ type Node struct

+ func NewTree() Node

+ func (n Node) AddEmptyLine()

+ func (n Node) AddLine(v string)

+ func (n Node) Child(text string) Node

+ func (n Node) Childf(format string, args ...interface{}) Node

+ func (n Node) FormattedRows() []string

+ func (n Node) String() string

+ type OneOverTime struct

+ type Params interface

+ Direction func() logproto.Direction

+ End func() time.Time

+ GetExpression func() syntax.Expr

+ Interval func() time.Duration

+ Limit func() uint32

+ QueryString func() string

+ Shards func() []string

+ Start func() time.Time

+ Step func() time.Duration

+ type ParamsWithExpressionOverride struct

+ ExpressionOverride syntax.Expr

+ func (p ParamsWithExpressionOverride) GetExpression() syntax.Expr

+ type ParamsWithShardsOverride struct

+ ShardsOverride []string

+ func (p ParamsWithShardsOverride) Shards() []string

+ type PowerOfTwoStrategy struct

+ func NewPowerOfTwoStrategy(resolver ShardResolver) PowerOfTwoStrategy

+ func (s PowerOfTwoStrategy) Resolver() ShardResolver

+ func (s PowerOfTwoStrategy) Shards(expr syntax.Expr) (Shards, uint64, error)

+ type ProbabilisticQuantileMatrix []ProbabilisticQuantileVector

+ func ProbabilisticQuantileMatrixFromProto(proto *logproto.QuantileSketchMatrix) (ProbabilisticQuantileMatrix, error)

+ func (ProbabilisticQuantileMatrix) String() string

+ func (ProbabilisticQuantileMatrix) Type() promql_parser.ValueType

+ func (m ProbabilisticQuantileMatrix) Merge(right ProbabilisticQuantileMatrix) (ProbabilisticQuantileMatrix, error)

+ func (m ProbabilisticQuantileMatrix) Release()

+ func (m ProbabilisticQuantileMatrix) ToProto() *logproto.QuantileSketchMatrix

+ type ProbabilisticQuantileSample struct

+ F sketch.QuantileSketch

+ Metric labels.Labels

+ T int64

+ func (q ProbabilisticQuantileSample) ToProto() *logproto.QuantileSketchSample

+ type ProbabilisticQuantileVector []ProbabilisticQuantileSample

+ func ProbabilisticQuantileVectorFromProto(proto *logproto.QuantileSketchVector) (ProbabilisticQuantileVector, error)

+ func (ProbabilisticQuantileVector) SampleVector() promql.Vector

+ func (q ProbabilisticQuantileVector) Merge(right ProbabilisticQuantileVector) (ProbabilisticQuantileVector, error)

+ func (q ProbabilisticQuantileVector) QuantileSketchVec() ProbabilisticQuantileVector

+ func (q ProbabilisticQuantileVector) Release()

+ func (q ProbabilisticQuantileVector) ToProto() *logproto.QuantileSketchVector

+ type QuantileOverTime struct

+ type QuantileSketchAccumulator struct

+ func (a *QuantileSketchAccumulator) Accumulate(_ context.Context, res logqlmodel.Result, _ int) error

+ func (a *QuantileSketchAccumulator) Result() []logqlmodel.Result

+ type QuantileSketchEvalExpr struct

+ func (e *QuantileSketchEvalExpr) Walk(f syntax.WalkFn)

+ func (e QuantileSketchEvalExpr) String() string

+ type QuantileSketchMatrixStepEvaluator struct

+ func NewQuantileSketchMatrixStepEvaluator(m ProbabilisticQuantileMatrix, params Params) *QuantileSketchMatrixStepEvaluator

+ func (*QuantileSketchMatrixStepEvaluator) Close() error

+ func (*QuantileSketchMatrixStepEvaluator) Error() error

+ func (*QuantileSketchMatrixStepEvaluator) Explain(parent Node)

+ func (m *QuantileSketchMatrixStepEvaluator) Next() (bool, int64, StepResult)

+ type QuantileSketchMergeExpr struct

+ func (e *QuantileSketchMergeExpr) Walk(f syntax.WalkFn)

+ func (e QuantileSketchMergeExpr) String() string

+ type QuantileSketchMergeStepEvaluator struct

+ func NewQuantileSketchMergeStepEvaluator(evaluators []StepEvaluator) *QuantileSketchMergeStepEvaluator

+ func (*QuantileSketchMergeStepEvaluator) Close() error

+ func (e *QuantileSketchMergeStepEvaluator) Error() error

+ func (e *QuantileSketchMergeStepEvaluator) Explain(parent Node)

+ func (e *QuantileSketchMergeStepEvaluator) Next() (bool, int64, StepResult)

+ type QuantileSketchStepEvaluator struct

+ func (e *QuantileSketchStepEvaluator) Close() error

+ func (e *QuantileSketchStepEvaluator) Error() error

+ func (e *QuantileSketchStepEvaluator) Explain(parent Node)

+ func (e *QuantileSketchStepEvaluator) Next() (bool, int64, StepResult)

+ type QuantileSketchVectorStepEvaluator struct

+ func NewQuantileSketchVectorStepEvaluator(inner StepEvaluator, quantile float64) *QuantileSketchVectorStepEvaluator

+ func (*QuantileSketchVectorStepEvaluator) Close() error

+ func (*QuantileSketchVectorStepEvaluator) Error() error

+ func (e *QuantileSketchVectorStepEvaluator) Explain(parent Node)

+ func (e *QuantileSketchVectorStepEvaluator) Next() (bool, int64, StepResult)

+ type Querier interface

+ SelectLogs func(context.Context, SelectLogParams) (iter.EntryIterator, error)

+ SelectSamples func(context.Context, SelectSampleParams) (iter.SampleIterator, error)

+ type Query interface

+ Exec func(ctx context.Context) (logqlmodel.Result, error)

+ type QueryParams interface

+ GetEnd func() time.Time

+ GetShards func() []string

+ GetStart func() time.Time

+ LogSelector func() (syntax.LogSelectorExpr, error)

+ type QueryRangeType string

+ var InstantType QueryRangeType = "instant"

+ var RangeType QueryRangeType = "range"

+ func GetRangeType(q Params) QueryRangeType

+ type RangeMapper struct

+ func NewRangeMapper(interval time.Duration, metrics *MapperMetrics, stats *MapperStats) (RangeMapper, error)

+ func NewRangeMapperWithSplitAlign(interval time.Duration, splitAlign time.Time, metrics *MapperMetrics, ...) (RangeMapper, error)

+ func (m RangeMapper) Map(expr syntax.SampleExpr, vectorAggrPushdown *syntax.VectorAggregationExpr, ...) (syntax.SampleExpr, error)

+ func (m RangeMapper) Parse(expr syntax.Expr) (bool, syntax.Expr, error)

+ type RangeStreamingAgg interface

+ type RangeVectorEvaluator struct

+ func (r *RangeVectorEvaluator) Close() error

+ func (r *RangeVectorEvaluator) Error() error

+ func (r *RangeVectorEvaluator) Explain(parent Node)

+ func (r *RangeVectorEvaluator) Next() (bool, int64, StepResult)

+ type RangeVectorIterator interface

+ At func() (int64, StepResult)

+ Close func() error

+ Error func() error

+ Next func() bool

+ type RateCounterOverTime struct

+ type RateLogBytesOverTime struct

+ type RateLogsOverTime struct

+ type Resp struct

+ Err error

+ I int

+ Res logqlmodel.Result

+ type SampleEvaluatorFactory interface

+ NewStepEvaluator func(ctx context.Context, nextEvaluatorFactory SampleEvaluatorFactory, ...) (StepEvaluator, error)

+ type SampleEvaluatorFunc func(ctx context.Context, nextEvaluatorFactory SampleEvaluatorFactory, ...) (StepEvaluator, error)

+ func (s SampleEvaluatorFunc) NewStepEvaluator(ctx context.Context, nextEvaluatorFactory SampleEvaluatorFactory, ...) (StepEvaluator, error)

+ type SampleVector promql.Vector

+ func (p SampleVector) QuantileSketchVec() ProbabilisticQuantileVector

+ func (p SampleVector) SampleVector() promql.Vector

+ type SelectLogParams struct

+ func (s SelectLogParams) LogSelector() (syntax.LogSelectorExpr, error)

+ func (s SelectLogParams) String() string

+ type SelectSampleParams struct

+ func (s SelectSampleParams) Expr() (syntax.SampleExpr, error)

+ func (s SelectSampleParams) LogSelector() (syntax.LogSelectorExpr, error)

+ type Shard struct

+ Bounded *logproto.Shard

+ PowerOfTwo *index.ShardAnnotation

+ func NewBoundedShard(shard logproto.Shard) Shard

+ func NewPowerOfTwoShard(shard index.ShardAnnotation) Shard

+ func (s *Shard) GetFromThrough() (model.Fingerprint, model.Fingerprint)

+ func (s *Shard) Match(fp model.Fingerprint) bool

+ func (s *Shard) Variant() ShardVersion

+ func (s Shard) Ptr() *Shard

+ func (s Shard) String() string

+ type ShardMapper struct

+ func NewShardMapper(strategy ShardingStrategy, metrics *MapperMetrics, shardAggregation []string) ShardMapper

+ func (m ShardMapper) Map(expr syntax.Expr, r *downstreamRecorder, topLevel bool) (syntax.Expr, uint64, error)

+ func (m ShardMapper) Parse(parsed syntax.Expr) (noop bool, bytesPerShard uint64, expr syntax.Expr, err error)

+ type ShardResolver interface

+ GetStats func(e syntax.Expr) (stats.Stats, error)

+ ShardingRanges func(expr syntax.Expr, targetBytesPerShard uint64) ([]logproto.Shard, error)

+ Shards func(expr syntax.Expr) (int, uint64, error)

+ type ShardVersion uint8

+ const BoundedVersion

+ const PowerOfTwoVersion

+ func ParseShardVersion(s string) (ShardVersion, error)

+ func (v ShardVersion) Strategy(resolver ShardResolver, defaultTargetShardBytes uint64) ShardingStrategy

+ func (v ShardVersion) String() string

+ type ShardingStrategy interface

+ Resolver func() ShardResolver

+ Shards func(expr syntax.Expr) (shards Shards, maxBytesPerShard uint64, err error)

+ type Shards []Shard

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

+ type StddevOverTime struct

+ type StdvarOverTime struct

+ type StepEvaluator interface

+ Close func() error

+ Error func() error

+ Explain func(Node)

+ Next func() (ok bool, ts int64, r StepResult)

+ func NewResultStepEvaluator(res logqlmodel.Result, params Params) (StepEvaluator, error)

+ type StepResult interface

+ QuantileSketchVec func() ProbabilisticQuantileVector

+ SampleVector func() promql.Vector

+ type SumOverTime struct

+ type VectorAggEvaluator struct

+ func (e *VectorAggEvaluator) Close() error

+ func (e *VectorAggEvaluator) Error() error

+ func (e *VectorAggEvaluator) Explain(parent Node)

+ func (e *VectorAggEvaluator) Next() (bool, int64, StepResult)

+ type VectorIterator struct

+ func (i *VectorIterator) Explain(parent Node)

+ func (r *VectorIterator) Close() error

+ func (r *VectorIterator) Error() error

+ func (r *VectorIterator) Next() (bool, int64, StepResult)

+ type VectorStepEvaluator struct

+ func NewVectorStepEvaluator(start time.Time, data promql.Vector) *VectorStepEvaluator

+ func (e *VectorStepEvaluator) Close() error

+ func (e *VectorStepEvaluator) Error() error

+ func (e *VectorStepEvaluator) Explain(parent Node)

+ func (e *VectorStepEvaluator) Next() (bool, int64, StepResult)

Other modules containing this package

github.com/grafana/loki

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL