syntax

package
v2.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 14, 2023 License: AGPL-3.0 Imports: 27 Imported by: 0

Documentation

Overview

This file is taken from the golang text/scanner package so `bufLen` can be set to `maxInputSize`.

Index

Constants

View Source 
const (
	// vector ops
	OpTypeSum      = "sum"
	OpTypeAvg      = "avg"
	OpTypeMax      = "max"
	OpTypeMin      = "min"
	OpTypeCount    = "count"
	OpTypeStddev   = "stddev"
	OpTypeStdvar   = "stdvar"
	OpTypeBottomK  = "bottomk"
	OpTypeTopK     = "topk"
	OpTypeSort     = "sort"
	OpTypeSortDesc = "sort_desc"

	// range vector ops
	OpRangeTypeCount       = "count_over_time"
	OpRangeTypeRate        = "rate"
	OpRangeTypeRateCounter = "rate_counter"
	OpRangeTypeBytes       = "bytes_over_time"
	OpRangeTypeBytesRate   = "bytes_rate"
	OpRangeTypeAvg         = "avg_over_time"
	OpRangeTypeSum         = "sum_over_time"
	OpRangeTypeMin         = "min_over_time"
	OpRangeTypeMax         = "max_over_time"
	OpRangeTypeStdvar      = "stdvar_over_time"
	OpRangeTypeStddev      = "stddev_over_time"
	OpRangeTypeQuantile    = "quantile_over_time"
	OpRangeTypeFirst       = "first_over_time"
	OpRangeTypeLast        = "last_over_time"
	OpRangeTypeAbsent      = "absent_over_time"

	//vector
	OpTypeVector = "vector"

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

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

	// binops - comparison
	OpTypeCmpEQ = "=="
	OpTypeNEQ   = "!="
	OpTypeGT    = ">"
	OpTypeGTE   = ">="
	OpTypeLT    = "<"
	OpTypeLTE   = "<="

	// parsers
	OpParserTypeJSON    = "json"
	OpParserTypeLogfmt  = "logfmt"
	OpParserTypeRegexp  = "regexp"
	OpParserTypeUnpack  = "unpack"
	OpParserTypePattern = "pattern"

	OpFmtLine    = "line_format"
	OpFmtLabel   = "label_format"
	OpDecolorize = "decolorize"

	OpPipe   = "|"
	OpUnwrap = "unwrap"
	OpOffset = "offset"

	OpOn       = "on"
	OpIgnoring = "ignoring"

	OpGroupLeft  = "group_left"
	OpGroupRight = "group_right"

	// conversion Op
	OpConvBytes           = "bytes"
	OpConvDuration        = "duration"
	OpConvDurationSeconds = "duration_seconds"

	OpLabelReplace = "label_replace"

	// function filters
	OpFilterIP = "ip"

	OpFilterDistinct = "distinct"

	// drop labels
	OpDrop = "drop"
)
View Source 
const (
	ScanIdents     = 1 << -Ident
	ScanInts       = 1 << -Int
	ScanFloats     = 1 << -Float // includes Ints and hexadecimal floats
	ScanChars      = 1 << -Char
	ScanStrings    = 1 << -String
	ScanRawStrings = 1 << -RawString
	ScanComments   = 1 << -Comment
	SkipComments   = 1 << -skipComment // if set with ScanComments, comments become white space
	GoTokens       = ScanIdents | ScanFloats | ScanChars | ScanStrings | ScanRawStrings | ScanComments | SkipComments
)

Predefined mode bits to control recognition of tokens. For instance, to configure a Scanner such that it only recognizes (Go) identifiers, integers, and skips comments, set the Scanner's Mode field to: 

ScanIdents | ScanInts | SkipComments

With the exceptions of comments, which are skipped if SkipComments is set, unrecognized tokens are not ignored. Instead, the scanner simply returns the respective individual characters (or possibly sub-tokens). For instance, if the mode is ScanIdents (not ScanStrings), the string "foo" is scanned as the token sequence '"' Ident '"'.

Use GoTokens to configure the Scanner such that it accepts all Go literal tokens including Go identifiers. Comments will be skipped.

View Source 
const (
	EOF = -(iota + 1)
	Ident
	Int
	Float
	Char
	String
	RawString
	Comment
)

The result of Scan is one of these tokens or a Unicode character.

View Source 
const ABSENT_OVER_TIME = 57406
View Source 
const ADD = 57428
View Source 
const AND = 57420
View Source 
const AVG = 57375
View Source 
const AVG_OVER_TIME = 57394
View Source 
const BOOL = 57385
View Source 
const BOTTOMK = 57381
View Source 
const BY = 57367
View Source 
const BYTES = 57346
View Source 
const BYTES_CONV = 57401
View Source 
const BYTES_OVER_TIME = 57383
View Source 
const BYTES_RATE = 57384
View Source 
const CLOSE_BRACE = 57358
View Source 
const CLOSE_BRACKET = 57360
View Source 
const CLOSE_PARENTHESIS = 57366
View Source 
const CMP_EQ = 57422
View Source 
const COMMA = 57361
View Source 
const COUNT = 57378
View Source 
const COUNT_OVER_TIME = 57369
View Source 
const DECOLORIZE = 57417
View Source 
const DISTINCT = 57387
View Source 
const DIV = 57431
View Source 
const DOT = 57362
View Source 
const DROP = 57418
View Source 
const DURATION = 57350
View Source 
const DURATION_CONV = 57402
View Source 
const DURATION_SECONDS_CONV = 57403
View Source 
const EQ = 57354
View Source 
const (
	EmptyMatchers = "{}"
)
View Source 
const FIRST_OVER_TIME = 57404
View Source 
const GROUP_LEFT = 57415
View Source 
const GROUP_RIGHT = 57416
View Source 
const GT = 57426
View Source 
const GTE = 57427
View Source 
const GoWhitespace = 1<<'\t' | 1<<'\n' | 1<<'\r' | 1<<' '

GoWhitespace is the default value for the Scanner's Whitespace field. Its value selects Go's white space characters.

View Source 
const IDENTIFIER = 57347
View Source 
const IGNORING = 57414
View Source 
const IP = 57412
View Source 
const JSON = 57386
View Source 
const LABELS = 57353
View Source 
const LABEL_FMT = 57392
View Source 
const LABEL_REPLACE = 57408
View Source 
const LAST_OVER_TIME = 57405
View Source 
const LINE_FMT = 57391
View Source 
const LOGFMT = 57389
View Source 
const LT = 57424
View Source 
const LTE = 57425
View Source 
const MATCHERS = 57352
View Source 
const MAX = 57376
View Source 
const MAX_OVER_TIME = 57397
View Source 
const MIN = 57377
View Source 
const MIN_OVER_TIME = 57396
View Source 
const MOD = 57432
View Source 
const MUL = 57430
View Source 
const NEQ = 57423
View Source 
const NRE = 57356
View Source 
const NUMBER = 57349
View Source 
const OFFSET = 57410
View Source 
const ON = 57413
View Source 
const OPEN_BRACE = 57357
View Source 
const OPEN_BRACKET = 57359
View Source 
const OPEN_PARENTHESIS = 57365
View Source 
const OR = 57419
View Source 
const PATTERN = 57411
View Source 
const PIPE = 57390
View Source 
const PIPE_EXACT = 57364
View Source 
const PIPE_MATCH = 57363
View Source 
const POW = 57433
View Source 
const QUANTILE_OVER_TIME = 57400
View Source 
const RANGE = 57351
View Source 
const RATE = 57370
View Source 
const RATE_COUNTER = 57371
View Source 
const RE = 57355
View Source 
const REGEXP = 57388
View Source 
const SORT = 57373
View Source 
const SORT_DESC = 57374
View Source 
const STDDEV = 57379
View Source 
const STDDEV_OVER_TIME = 57399
View Source 
const STDVAR = 57380
View Source 
const STDVAR_OVER_TIME = 57398
View Source 
const STRING = 57348
View Source 
const SUB = 57429
View Source 
const SUM = 57372
View Source 
const SUM_OVER_TIME = 57395
View Source 
const TOPK = 57382
View Source 
const UNLESS = 57421
View Source 
const UNPACK = 57409
View Source 
const UNWRAP = 57393
View Source 
const UnsupportedErr = "unsupported range vector aggregation operation: %s"
View Source 
const VECTOR = 57407
View Source 
const WITHOUT = 57368

Variables

This section is empty.

Functions

func IsComparisonOperator 

func IsComparisonOperator(op string) bool

func IsLogicalBinOp 

func IsLogicalBinOp(op string) bool

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

func MatchersString 

func MatchersString(xs []*labels.Matcher) string

func MergeBinOp 

func MergeBinOp(op string, left, right *promql.Sample, filter, isVectorComparison bool) (*promql.Sample, error)

func ParseLabels 

func ParseLabels(lbs string) (labels.Labels, error)

ParseLabels parses labels from a string using logql parser.

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 Prettify 

func Prettify(e Expr) string

func TokenString 

func TokenString(tok rune) string

TokenString returns a printable string for a token or Unicode character.

Types

type BinOpExpr 

type BinOpExpr struct {
	SampleExpr
	RHS  SampleExpr
	Op   string
	Opts *BinOpOptions
	// contains filtered or unexported fields
}

func (*BinOpExpr) MatcherGroups 

func (e *BinOpExpr) MatcherGroups() ([]MatcherRange, error)

func (*BinOpExpr) Pretty 

func (e *BinOpExpr) Pretty(level int) string

e.g: Any operations involving "or", "and" and "unless" (logical/set) "+", "-", "*", "/", "%", "^" (arithmetic) "==", "!=", ">", ">=", "<", "<=" (comparison)

func (*BinOpExpr) Shardable 

func (e *BinOpExpr) Shardable() bool

impl SampleExpr

func (*BinOpExpr) String 

func (e *BinOpExpr) String() string

func (*BinOpExpr) Walk 

func (e *BinOpExpr) Walk(f WalkFn)

type BinOpOptions 

type BinOpOptions struct {
	ReturnBool     bool
	VectorMatching *VectorMatching
}

type DecolorizeExpr 

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

func (*DecolorizeExpr) Pretty 

func (e *DecolorizeExpr) Pretty(_ int) string

e.g: | decolorize

func (*DecolorizeExpr) Shardable 

func (e *DecolorizeExpr) Shardable() bool

func (*DecolorizeExpr) Stage 

func (e *DecolorizeExpr) Stage() (log.Stage, error)

func (*DecolorizeExpr) String 

func (e *DecolorizeExpr) String() string

func (*DecolorizeExpr) Walk 

func (e *DecolorizeExpr) Walk(f WalkFn)

type DistinctFilterExpr 

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

func (*DistinctFilterExpr) Pretty 

func (e *DistinctFilterExpr) Pretty(level int) string

func (*DistinctFilterExpr) Shardable 

func (e *DistinctFilterExpr) Shardable() bool

func (*DistinctFilterExpr) Stage 

func (e *DistinctFilterExpr) Stage() (log.Stage, error)

func (*DistinctFilterExpr) String 

func (e *DistinctFilterExpr) String() string

func (*DistinctFilterExpr) Walk 

func (e *DistinctFilterExpr) Walk(f WalkFn)

type DropLabelsExpr 

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

func (*DropLabelsExpr) Pretty 

func (e *DropLabelsExpr) Pretty(level int) string

func (*DropLabelsExpr) Shardable 

func (e *DropLabelsExpr) Shardable() bool

func (*DropLabelsExpr) Stage 

func (e *DropLabelsExpr) Stage() (log.Stage, error)

func (*DropLabelsExpr) String 

func (e *DropLabelsExpr) String() string

func (*DropLabelsExpr) Walk 

func (e *DropLabelsExpr) Walk(f WalkFn)

type Expr 

type Expr interface {
	Shardable() bool // A recursive check on the AST to see if it's shardable.
	Walkable
	fmt.Stringer

	// Pretty prettyfies any LogQL expression at given `level` of the whole LogQL query.
	Pretty(level int) string
	// contains filtered or unexported methods
}

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

func Clone 

func Clone(e Expr) (Expr, error)

func ParseExpr 

func ParseExpr(input string) (Expr, error)

ParseExpr parses a string and returns an Expr.

func ParseExprWithoutValidation 

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

type Grouping 

type Grouping struct {
	Groups  []string
	Without bool
}

func (*Grouping) Pretty 

func (g *Grouping) Pretty(_ int) string

e.g: by(container,namespace) -> by (container, namespace)

func (Grouping) String 

func (g Grouping) String() string

impls Stringer

type JSONExpressionParser 

type JSONExpressionParser struct {
	Expressions []log.LabelExtractionExpr
	// contains filtered or unexported fields
}

func (*JSONExpressionParser) Pretty 

func (e *JSONExpressionParser) Pretty(level int) string

e.g: | json label="expression", another="expression"

func (*JSONExpressionParser) Shardable 

func (j *JSONExpressionParser) Shardable() bool

func (*JSONExpressionParser) Stage 

func (j *JSONExpressionParser) Stage() (log.Stage, error)

func (*JSONExpressionParser) String 

func (j *JSONExpressionParser) String() string

func (*JSONExpressionParser) Walk 

func (j *JSONExpressionParser) Walk(f WalkFn)

type LabelFilterExpr 

type LabelFilterExpr struct {
	log.LabelFilterer
	// contains filtered or unexported fields
}

func (*LabelFilterExpr) Pretty 

func (e *LabelFilterExpr) Pretty(level int) string

e.g: | level!="error"

func (*LabelFilterExpr) Shardable 

func (e *LabelFilterExpr) Shardable() bool

func (*LabelFilterExpr) Stage 

func (e *LabelFilterExpr) Stage() (log.Stage, error)

func (*LabelFilterExpr) String 

func (e *LabelFilterExpr) String() string

func (*LabelFilterExpr) Walk 

func (e *LabelFilterExpr) Walk(f WalkFn)

type LabelFmtExpr 

type LabelFmtExpr struct {
	Formats []log.LabelFmt
	// contains filtered or unexported fields
}

func (*LabelFmtExpr) Pretty 

func (e *LabelFmtExpr) Pretty(level int) string

e.g: | label_format dst="{{ .src }}"

func (*LabelFmtExpr) Shardable 

func (e *LabelFmtExpr) Shardable() bool

func (*LabelFmtExpr) Stage 

func (e *LabelFmtExpr) Stage() (log.Stage, error)

func (*LabelFmtExpr) String 

func (e *LabelFmtExpr) String() string

func (*LabelFmtExpr) Walk 

func (e *LabelFmtExpr) Walk(f WalkFn)

type LabelParserExpr 

type LabelParserExpr struct {
	Op    string
	Param string
	// contains filtered or unexported fields
}

func (*LabelParserExpr) Pretty 

func (e *LabelParserExpr) Pretty(level int) string

e.g: `| logfmt` `| json` `| regexp` `| pattern` `| unpack`

func (*LabelParserExpr) Shardable 

func (e *LabelParserExpr) Shardable() bool

func (*LabelParserExpr) Stage 

func (e *LabelParserExpr) Stage() (log.Stage, error)

func (*LabelParserExpr) String 

func (e *LabelParserExpr) String() string

func (*LabelParserExpr) Walk 

func (e *LabelParserExpr) Walk(f WalkFn)

type LabelReplaceExpr 

type LabelReplaceExpr struct {
	Left        SampleExpr
	Dst         string
	Replacement string
	Src         string
	Regex       string
	Re          *regexp.Regexp
	// contains filtered or unexported fields
}

func (*LabelReplaceExpr) Extractor 

func (e *LabelReplaceExpr) Extractor() (SampleExtractor, error)

func (*LabelReplaceExpr) MatcherGroups 

func (e *LabelReplaceExpr) MatcherGroups() ([]MatcherRange, error)

func (*LabelReplaceExpr) Pretty 

func (e *LabelReplaceExpr) Pretty(level int) string

e.g: label_replace(rate({job="api-server",service="a:c"}[5m]), "foo", "$1", "service", "(.*):.*")

func (*LabelReplaceExpr) Selector 

func (e *LabelReplaceExpr) Selector() (LogSelectorExpr, error)

func (*LabelReplaceExpr) Shardable 

func (e *LabelReplaceExpr) Shardable() bool

func (*LabelReplaceExpr) String 

func (e *LabelReplaceExpr) String() string

func (*LabelReplaceExpr) Walk 

func (e *LabelReplaceExpr) Walk(f WalkFn)

type LineFilterExpr 

type LineFilterExpr struct {
	Left  *LineFilterExpr
	Ty    labels.MatchType
	Match string
	Op    string
	// contains filtered or unexported fields
}

func (*LineFilterExpr) Filter 

func (e *LineFilterExpr) Filter() (log.Filterer, error)

func (*LineFilterExpr) Pretty 

func (e *LineFilterExpr) Pretty(level int) string

e.g: `|= "error" != "memcache" |= ip("192.168.0.1")` NOTE: here `ip` is Op in this expression.

func (*LineFilterExpr) Shardable 

func (e *LineFilterExpr) Shardable() bool

func (*LineFilterExpr) Stage 

func (e *LineFilterExpr) Stage() (log.Stage, error)

func (*LineFilterExpr) String 

func (e *LineFilterExpr) String() string

func (*LineFilterExpr) Walk 

func (e *LineFilterExpr) Walk(f WalkFn)

type LineFmtExpr 

type LineFmtExpr struct {
	Value string
	// contains filtered or unexported fields
}

func (*LineFmtExpr) Pretty 

func (e *LineFmtExpr) Pretty(level int) string

e.g: | line_format "{{ .label }}"

func (*LineFmtExpr) Shardable 

func (e *LineFmtExpr) Shardable() bool

func (*LineFmtExpr) Stage 

func (e *LineFmtExpr) Stage() (log.Stage, error)

func (*LineFmtExpr) String 

func (e *LineFmtExpr) String() string

func (*LineFmtExpr) Walk 

func (e *LineFmtExpr) Walk(f WalkFn)

type LiteralExpr 

type LiteralExpr struct {
	Val float64
	// contains filtered or unexported fields
}

func (*LiteralExpr) Extractor 

func (e *LiteralExpr) Extractor() (log.SampleExtractor, error)

func (*LiteralExpr) HasFilter 

func (e *LiteralExpr) HasFilter() bool

func (*LiteralExpr) MatcherGroups 

func (e *LiteralExpr) MatcherGroups() ([]MatcherRange, error)

func (*LiteralExpr) Matchers 

func (e *LiteralExpr) Matchers() []*labels.Matcher

func (*LiteralExpr) Pipeline 

func (e *LiteralExpr) Pipeline() (log.Pipeline, error)

func (*LiteralExpr) Pretty 

func (e *LiteralExpr) Pretty(level int) string

e.g: 4.6

func (*LiteralExpr) Selector 

func (e *LiteralExpr) Selector() (LogSelectorExpr, error)

literlExpr impls SampleExpr & LogSelectorExpr mainly to reduce the need for more complicated typings to facilitate sum types. We'll be type switching when evaluating them anyways and they will only be present in binary operation legs.

func (*LiteralExpr) Shardable 

func (e *LiteralExpr) Shardable() bool

func (*LiteralExpr) String 

func (e *LiteralExpr) String() string

func (*LiteralExpr) Value 

func (e *LiteralExpr) Value() (float64, error)

func (*LiteralExpr) Walk 

func (e *LiteralExpr) Walk(f WalkFn)

type LogPipelineExpr 

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

LogPipelineExpr is an expression defining a log pipeline.

type LogRange 

type LogRange struct {
	Left     LogSelectorExpr
	Interval time.Duration
	Offset   time.Duration

	Unwrap *UnwrapExpr
	// contains filtered or unexported fields
}

func (*LogRange) Pretty 

func (e *LogRange) Pretty(level int) string

e.g: `{foo="bar"}|logfmt[5m]` TODO(kavi): Rename `LogRange` -> `LogRangeExpr` (to be consistent with other expressions?)

func (*LogRange) Shardable 

func (r *LogRange) Shardable() bool

func (LogRange) String 

func (r LogRange) String() string

impls Stringer

func (*LogRange) Walk 

func (r *LogRange) Walk(f WalkFn)

type LogSelectorExpr 

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

LogSelectorExpr is a LogQL expression filtering and returning logs.

func AddFilterExpr 

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

AddFilterExpr adds a filter expression to a logselector expression.

func ParseLogSelector 

func ParseLogSelector(input string, validate bool) (LogSelectorExpr, error)

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

type LogfmtExpressionParser 

type LogfmtExpressionParser struct {
	Expressions []log.LabelExtractionExpr
	// contains filtered or unexported fields
}

func (*LogfmtExpressionParser) Pretty 

func (e *LogfmtExpressionParser) Pretty(level int) string

e.g: | logfmt label="expression", another="expression"

func (*LogfmtExpressionParser) Shardable 

func (l *LogfmtExpressionParser) Shardable() bool

func (*LogfmtExpressionParser) Stage 

func (l *LogfmtExpressionParser) Stage() (log.Stage, error)

func (*LogfmtExpressionParser) String 

func (l *LogfmtExpressionParser) String() string

func (*LogfmtExpressionParser) Walk 

func (l *LogfmtExpressionParser) Walk(f WalkFn)

type MatcherRange 

type MatcherRange struct {
	Matchers         []*labels.Matcher
	Interval, Offset time.Duration
}

func MatcherGroups 

func MatcherGroups(expr Expr) ([]MatcherRange, error)

type MatchersExpr 

type MatchersExpr struct {
	Mts []*labels.Matcher
	// contains filtered or unexported fields
}

func (*MatchersExpr) AppendMatchers 

func (e *MatchersExpr) AppendMatchers(m []*labels.Matcher)

func (*MatchersExpr) HasFilter 

func (e *MatchersExpr) HasFilter() bool

func (*MatchersExpr) Matchers 

func (e *MatchersExpr) Matchers() []*labels.Matcher

func (*MatchersExpr) Pipeline 

func (e *MatchersExpr) Pipeline() (log.Pipeline, error)

func (*MatchersExpr) Pretty 

func (e *MatchersExpr) Pretty(level int) string

e.g: `{foo="bar"}`

func (*MatchersExpr) Shardable 

func (e *MatchersExpr) Shardable() bool

func (*MatchersExpr) String 

func (e *MatchersExpr) String() string

func (*MatchersExpr) Walk 

func (e *MatchersExpr) Walk(f WalkFn)

type MultiStageExpr 

type MultiStageExpr []StageExpr

MultiStageExpr is multiple stages which implement a PipelineExpr.

func (MultiStageExpr) Pipeline 

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

func (MultiStageExpr) String 

func (m MultiStageExpr) String() string

type OffsetExpr 

type OffsetExpr struct {
	Offset time.Duration
}

func (*OffsetExpr) Pretty 

func (e *OffsetExpr) Pretty(_ int) string

e.g: count_over_time({foo="bar"}[5m] offset 3h) TODO(kavi): why does offset not work in log queries? e.g: `{foo="bar"} offset 1h`? is it bug? or anything else? NOTE: Also offset expression never to be indented. It always goes with its parent expression (usually RangeExpr).

func (*OffsetExpr) String 

func (o *OffsetExpr) String() string

type Pipeline 

type Pipeline = log.Pipeline

Type alias for backward compatibility

type PipelineExpr 

type PipelineExpr struct {
	MultiStages MultiStageExpr
	Left        *MatchersExpr
	// contains filtered or unexported fields
}

func (*PipelineExpr) HasFilter 

func (e *PipelineExpr) HasFilter() bool

HasFilter returns true if the pipeline contains stage that can filter out lines.

func (*PipelineExpr) Matchers 

func (e *PipelineExpr) Matchers() []*labels.Matcher

func (*PipelineExpr) Pipeline 

func (e *PipelineExpr) Pipeline() (log.Pipeline, error)

func (*PipelineExpr) Pretty 

func (e *PipelineExpr) Pretty(level int) string

e.g: `{foo="bar"} | logfmt | level="error"` Here, left = `{foo="bar"}` and multistages would collection of each stage in pipeline, here `logfmt` and `level="error"`

func (*PipelineExpr) Shardable 

func (e *PipelineExpr) Shardable() bool

func (*PipelineExpr) String 

func (e *PipelineExpr) String() string

func (*PipelineExpr) Walk 

func (e *PipelineExpr) Walk(f WalkFn)

type Position 

type Position struct {
	Filename string // filename, if any
	Offset   int    // byte offset, starting at 0
	Line     int    // line number, starting at 1
	Column   int    // column number, starting at 1 (character count per line)
}

Position is a value that represents a source position. A position is valid if Line > 0.

func (*Position) IsValid 

func (pos *Position) IsValid() bool

IsValid reports whether the position is valid.

func (Position) String 

func (pos Position) String() string

type RangeAggregationExpr 

type RangeAggregationExpr struct {
	Left      *LogRange
	Operation string

	Params   *float64
	Grouping *Grouping
	// contains filtered or unexported fields
}

func (RangeAggregationExpr) Extractor 

func (r RangeAggregationExpr) Extractor() (log.SampleExtractor, error)

func (*RangeAggregationExpr) MatcherGroups 

func (e *RangeAggregationExpr) MatcherGroups() ([]MatcherRange, error)

func (*RangeAggregationExpr) Pretty 

func (e *RangeAggregationExpr) Pretty(level int) string

e.g: count_over_time({foo="bar"}[5m])

func (*RangeAggregationExpr) Selector 

func (e *RangeAggregationExpr) Selector() (LogSelectorExpr, error)

func (*RangeAggregationExpr) Shardable 

func (e *RangeAggregationExpr) Shardable() bool

impl SampleExpr

func (*RangeAggregationExpr) String 

func (e *RangeAggregationExpr) String() string

impls Stringer

func (RangeAggregationExpr) Validate 

func (e RangeAggregationExpr) Validate() error

func (*RangeAggregationExpr) Walk 

func (e *RangeAggregationExpr) Walk(f WalkFn)

type SampleExpr 

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

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

func ParseSampleExpr 

func ParseSampleExpr(input string) (SampleExpr, error)

ParseSampleExpr parses a string and returns the sampleExpr

type SampleExtractor 

type SampleExtractor = log.SampleExtractor

Type alias for backward compatibility

type Scanner 

type Scanner struct {

	// Error is called for each error encountered. If no Error
	// function is set, the error is reported to os.Stderr.
	Error func(s *Scanner, msg string)

	// ErrorCount is incremented by one for each error encountered.
	ErrorCount int

	// The Mode field controls which tokens are recognized. For instance,
	// to recognize Ints, set the ScanInts bit in Mode. The field may be
	// changed at any time.
	Mode uint

	// The Whitespace field controls which characters are recognized
	// as white space. To recognize a character ch <= ' ' as white space,
	// set the ch'th bit in Whitespace (the Scanner's behavior is undefined
	// for values ch > ' '). The field may be changed at any time.
	Whitespace uint64

	// IsIdentRune is a predicate controlling the characters accepted
	// as the ith rune in an identifier. The set of valid characters
	// must not intersect with the set of white space characters.
	// If no IsIdentRune function is set, regular Go identifiers are
	// accepted instead. The field may be changed at any time.
	IsIdentRune func(ch rune, i int) bool

	// Start position of most recently scanned token; set by Scan.
	// Calling Init or Next invalidates the position (Line == 0).
	// The Filename field is always left untouched by the Scanner.
	// If an error is reported (via Error) and Position is invalid,
	// the scanner is not inside a token. Call Pos to obtain an error
	// position in that case, or to obtain the position immediately
	// after the most recently scanned token.
	Position
	// contains filtered or unexported fields
}

A Scanner implements reading of Unicode characters and tokens from an io.Reader.

func (*Scanner) Init 

func (s *Scanner) Init(src io.Reader) *Scanner

Init initializes a Scanner with a new source and returns s. Error is set to nil, ErrorCount is set to 0, Mode is set to GoTokens, and Whitespace is set to GoWhitespace.

func (*Scanner) Next 

func (s *Scanner) Next() rune

Next reads and returns the next Unicode character. It returns EOF at the end of the source. It reports a read error by calling s.Error, if not nil; otherwise it prints an error message to os.Stderr. Next does not update the Scanner's Position field; use Pos() to get the current position.

func (*Scanner) Peek 

func (s *Scanner) Peek() rune

Peek returns the next Unicode character in the source without advancing the scanner. It returns EOF if the scanner's position is at the last character of the source.

func (*Scanner) Pos 

func (s *Scanner) Pos() (pos Position)

Pos returns the position of the character immediately after the character or token returned by the last call to Next or Scan. Use the Scanner's Position field for the start position of the most recently scanned token.

func (*Scanner) Scan 

func (s *Scanner) Scan() rune

Scan reads the next token or Unicode character from source and returns it. It only recognizes tokens t for which the respective Mode bit (1<<-t) is set. It returns EOF at the end of the source. It reports scanner errors (read and token errors) by calling s.Error, if not nil; otherwise it prints an error message to os.Stderr.

func (*Scanner) TokenText 

func (s *Scanner) TokenText() string

TokenText returns the string corresponding to the most recently scanned token. Valid after calling Scan and in calls of Scanner.Error.

type StageExpr 

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

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

type UnwrapExpr 

type UnwrapExpr struct {
	Identifier string
	Operation  string

	PostFilters []log.LabelFilterer
}

func (*UnwrapExpr) Pretty 

func (e *UnwrapExpr) Pretty(level int) string

e.g: sum_over_time({foo="bar"} | logfmt | unwrap bytes_processed [5m])

func (UnwrapExpr) String 

func (u UnwrapExpr) String() string

type VectorAggregationExpr 

type VectorAggregationExpr struct {
	Left SampleExpr

	Grouping  *Grouping
	Params    int
	Operation string
	// contains filtered or unexported fields
}

func (*VectorAggregationExpr) Extractor 

func (e *VectorAggregationExpr) Extractor() (log.SampleExtractor, error)

func (*VectorAggregationExpr) MatcherGroups 

func (e *VectorAggregationExpr) MatcherGroups() ([]MatcherRange, error)

func (*VectorAggregationExpr) Pretty 

func (e *VectorAggregationExpr) Pretty(level int) string

Syntax: <aggr-op>([parameter,] <vector expression>) [without|by (<label list>)] <aggr-op> - sum, avg, bottomk, topk, etc. [parameters,] - optional params, used only by bottomk and topk for now. <vector expression> - vector on which aggregation is done. [without|by (<label list)] - optional labels to aggregate either with `by` or `without` clause.

func (*VectorAggregationExpr) Selector 

func (e *VectorAggregationExpr) Selector() (LogSelectorExpr, error)

func (*VectorAggregationExpr) Shardable 

func (e *VectorAggregationExpr) Shardable() bool

impl SampleExpr

func (*VectorAggregationExpr) String 

func (e *VectorAggregationExpr) String() string

func (*VectorAggregationExpr) Walk 

func (e *VectorAggregationExpr) Walk(f WalkFn)

type VectorExpr 

type VectorExpr struct {
	Val float64
	// contains filtered or unexported fields
}

func NewVectorExpr 

func NewVectorExpr(scalar string) *VectorExpr

func (*VectorExpr) Err 

func (e *VectorExpr) Err() error

func (*VectorExpr) Extractor 

func (e *VectorExpr) Extractor() (log.SampleExtractor, error)

func (*VectorExpr) HasFilter 

func (e *VectorExpr) HasFilter() bool

func (*VectorExpr) MatcherGroups 

func (e *VectorExpr) MatcherGroups() ([]MatcherRange, error)

func (*VectorExpr) Matchers 

func (e *VectorExpr) Matchers() []*labels.Matcher

func (*VectorExpr) Pipeline 

func (e *VectorExpr) Pipeline() (log.Pipeline, error)

func (*VectorExpr) Pretty 

func (e *VectorExpr) Pretty(level int) string

e.g: vector(5)

func (*VectorExpr) Selector 

func (e *VectorExpr) Selector() (LogSelectorExpr, error)

func (*VectorExpr) Shardable 

func (e *VectorExpr) Shardable() bool

func (*VectorExpr) String 

func (e *VectorExpr) String() string

func (*VectorExpr) Value 

func (e *VectorExpr) Value() (float64, error)

func (*VectorExpr) Walk 

func (e *VectorExpr) Walk(f WalkFn)

type VectorMatchCardinality 

type VectorMatchCardinality int

VectorMatchCardinality describes the cardinality relationship of two Vectors in a binary operation. 

const (
	CardOneToOne VectorMatchCardinality = iota
	CardManyToOne
	CardOneToMany
)

func (VectorMatchCardinality) String 

func (vmc VectorMatchCardinality) String() string

type VectorMatching 

type VectorMatching struct {
	// The cardinality of the two Vectors.
	Card VectorMatchCardinality
	// MatchingLabels contains the labels which define equality of a pair of
	// elements from the Vectors.
	MatchingLabels []string
	// On includes the given label names from matching,
	// rather than excluding them.
	On bool
	// Include contains additional labels that should be included in
	// the result from the side with the lower cardinality.
	Include []string
}

VectorMatching describes how elements from two Vectors in a binary operation are supposed to be matched.

type WalkFn 

type WalkFn = func(e interface{})

type Walkable 

type Walkable interface {
	Walk(f WalkFn)
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.