astmapper

Documentation

Index

• Constants
• Variables
• func CanParallelize(expr parser.Expr, logger log.Logger) bool
• func ParallelizableFunc(f parser.Function) bool
• type ASTExprMapper
  • func NewASTExprMapper(mapper ExprMapper) ASTExprMapper
  • func (em ASTExprMapper) Map(expr parser.Expr) (parser.Expr, error)
• type ASTMapper
  • func NewInstantQuerySplitter(ctx context.Context, interval time.Duration, logger log.Logger, ...) ASTMapper
  • func NewSharding(ctx context.Context, shards int, logger log.Logger, stats *MapperStats) (ASTMapper, error)
• type EmbeddedQueries
• type ExprMapper
• type InstantSplitterStats
  • func NewInstantSplitterStats() *InstantSplitterStats
  • func (s *InstantSplitterStats) AddSplitQueries(num int)
  • func (s *InstantSplitterStats) GetSkippedReason() SkippedReason
  • func (s *InstantSplitterStats) GetSplitQueries() int
  • func (s *InstantSplitterStats) SetSkippedReason(reason SkippedReason)
• type MapperStats
  • func NewMapperStats() *MapperStats
  • func (s *MapperStats) AddShardedQueries(num int)
  • func (s *MapperStats) GetShardedQueries() int
• type MultiMapper
  • func NewMultiMapper(xs ...ASTMapper) *MultiMapper
  • func (m *MultiMapper) Map(expr parser.Expr) (parser.Expr, error)
  • func (m *MultiMapper) Register(xs ...ASTMapper)
• type SkippedReason

Constants

const (
	// EmbeddedQueriesLabelName is a reserved label name containing embedded queries.
	EmbeddedQueriesLabelName = "__queries__"

	// EmbeddedQueriesMetricName is a reserved metric name denoting a special metric which contains embedded queries.
	EmbeddedQueriesMetricName = "__embedded_queries__"
)

const (
	SkippedReasonSmallInterval = SkippedReason("small-interval")
	SkippedReasonSubquery      = SkippedReason("subquery")
	SkippedReasonNonSplittable = SkippedReason("non-splittable")
)

Possible skipped reasons

Variables

var FuncsWithDefaultTimeArg = []string{
	"day_of_month",
	"day_of_week",
	"day_of_year",
	"days_in_month",
	"hour",
	"minute",
	"month",
	"year",
}

FuncsWithDefaultTimeArg is the list of functions that extract date information from a variadic list of params, which defaults to be just time() otherwise.

var JSONCodec jsonCodec

JSONCodec is a Codec that uses JSON representations of EmbeddedQueries structs

var NonParallelFuncs = []string{

	"absent",
	"absent_over_time",
	"histogram_quantile",
	"sort_desc",
	"sort_by_label",
	"sort_by_label_desc",
	"sort",
	"time",
	"vector",

	"histogram_avg",
}

NonParallelFuncs is the list of functions that shouldn't be parallelized.

Functions

func CanParallelize

func CanParallelize(expr parser.Expr, logger log.Logger) bool

CanParallelize tests if a subtree is parallelizable. A subtree is parallelizable if all of its components are parallelizable.

func ParallelizableFunc

func ParallelizableFunc(f parser.Function) bool

ParallelizableFunc ensures that a promql function can be part of a parallel query.

Types

type ASTExprMapper

type ASTExprMapper struct {
	ExprMapper
}

ASTExprMapper is an ASTMapper adapter which uses a ExprMapper internally.

func NewASTExprMapper

func NewASTExprMapper(mapper ExprMapper) ASTExprMapper

NewASTExprMapper creates an ASTMapper from a ExprMapper

func (ASTExprMapper) Map

func (em ASTExprMapper) Map(expr parser.Expr) (parser.Expr, error)

Map implements ASTMapper from a ExprMapper

type ASTMapper

type ASTMapper interface {
	// Map the input expr and returns the mapped expr.
	Map(expr parser.Expr) (mapped parser.Expr, err error)
}

ASTMapper is the exported interface for mapping between multiple AST representations

func NewInstantQuerySplitter

func NewInstantQuerySplitter(ctx context.Context, interval time.Duration, logger log.Logger, stats *InstantSplitterStats) ASTMapper

NewInstantQuerySplitter creates a new query range mapper.

func NewSharding

func NewSharding(ctx context.Context, shards int, logger log.Logger, stats *MapperStats) (ASTMapper, error)

NewSharding creates a new query sharding mapper.

type EmbeddedQueries

type EmbeddedQueries struct {
	Concat []string `json:"Concat"`
}

EmbeddedQueries is a wrapper type for encoding queries

type ExprMapper

type ExprMapper interface {
	// MapExpr either maps a single AST expr or returns the unaltered expr.
	// It returns a finished bool to signal whether no further recursion is necessary.
	MapExpr(expr parser.Expr) (mapped parser.Expr, finished bool, err error)
}

type InstantSplitterStats

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

func NewInstantSplitterStats

func NewInstantSplitterStats() *InstantSplitterStats

func (*InstantSplitterStats) AddSplitQueries

func (s *InstantSplitterStats) AddSplitQueries(num int)

AddSplitQueries add num split queries to the counter.

func (*InstantSplitterStats) GetSkippedReason

func (s *InstantSplitterStats) GetSkippedReason() SkippedReason

GetSkippedReason returns the reason a query is a no operation. If number of split queries is greater than 0, it means the query is splittable Otherwise, if no skipped reason is set, it means the query is non-splittable

func (*InstantSplitterStats) GetSplitQueries

func (s *InstantSplitterStats) GetSplitQueries() int

GetSplitQueries returns the number of split queries.

func (*InstantSplitterStats) SetSkippedReason

func (s *InstantSplitterStats) SetSkippedReason(reason SkippedReason)

SetSkippedReason set no operation reason for query.

type MapperStats

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

func NewMapperStats

func NewMapperStats() *MapperStats

func (*MapperStats) AddShardedQueries

func (s *MapperStats) AddShardedQueries(num int)

AddShardedQueries add num sharded queries to the counter.

func (*MapperStats) GetShardedQueries

func (s *MapperStats) GetShardedQueries() int

GetShardedQueries returns the number of sharded queries.

type MultiMapper

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

MultiMapper can compose multiple ASTMappers

func NewMultiMapper

func NewMultiMapper(xs ...ASTMapper) *MultiMapper

NewMultiMapper instantiates an ASTMapper from multiple ASTMappers.

func (*MultiMapper) Map

func (m *MultiMapper) Map(expr parser.Expr) (parser.Expr, error)

Map implements ASTMapper

func (*MultiMapper) Register

func (m *MultiMapper) Register(xs ...ASTMapper)

Register adds ASTMappers into a multimapper. Since registered functions are applied in the order they're registered, it's advised to register them in decreasing priority and only operate on exprs that each function cares about, defaulting to cloneExpr.

type SkippedReason

type SkippedReason string