logqlengine

type AndLabelMatcher struct {
	Left  Processor
	Right Processor
}

type BinOp struct {
	Left, Right MetricNode
	Expr        *logql.BinOpExpr
}

type BucketedSampleNode interface {
	// EvalBucketedSample evaluates the node, returning one Step per output
	// step in [params.Start, params.End) spaced params.Step apart, each
	// aggregating samples whose timestamp falls within the trailing window
	// of length window ending at that step.
	EvalBucketedSample(ctx context.Context, params EvalParams, window time.Duration) (StepIterator, error)
}

type BytesLabelFilter[C Comparator[uint64]] struct {
	// contains filtered or unexported fields
}

type Comparator[T any] interface {
	Compare(a, b T) bool
}

type ContainsMatcher struct {
	Value string
}

type Decolorize struct{}

type Direction string

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

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

type DurationLabelFilter[C Comparator[time.Duration]] struct {
	// contains filtered or unexported fields
}

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

type Entry struct {
	Timestamp otelstorage.Timestamp
	Line      string
	Set       logqlabels.LabelSet
}

type EntryIterator = iterators.Iterator[Entry]

type EqComparator[T comparable] struct{}

type EqualIPMatcher struct {
	Value netip.Addr
}

type EqualsMatcher struct {
	Value string
}

type EvalParams struct {
	Start     time.Time
	End       time.Time
	Step      time.Duration
	Direction Direction // forward, backward
	Limit     int       // -1 if query should be unlimited.
}

type ExplainQuery struct {
	Explain Query
	// contains filtered or unexported fields
}

type FastRegexpMatcher struct {
	Re *labels.FastRegexMatcher
}

type GtComparator[T cmp.Ordered] struct{}

type GteComparator[T cmp.Ordered] struct{}

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

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

type IPMatcher interface {
	Matcher[netip.Addr]
}

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

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

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

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

type LabelReplace struct {
	Input MetricNode
	Expr  *logql.LabelReplaceExpr
}

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

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

type LiteralBinOp struct {
	Input           MetricNode
	Literal         float64
	IsLiteralOnLeft bool
	Expr            *logql.BinOpExpr
}

type LiteralQuery struct {
	Value float64
	// contains filtered or unexported fields
}

type LogQuery struct {
	Root             PipelineNode
	LookbackDuration time.Duration
	// contains filtered or unexported fields
}

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

type LtComparator[T cmp.Ordered] struct{}

type LteComparator[T cmp.Ordered] struct{}

type Matcher[T any] interface {
	Match(T) bool
}

type MetricNode interface {
	Node
	EvalMetric(ctx context.Context, params MetricParams) (StepIterator, error)
}

type MetricParams struct {
	Start time.Time
	End   time.Time
	Step  time.Duration
}

type MetricQuery struct {
	Root MetricNode
	// contains filtered or unexported fields
}

type Node interface {
	// Traverse calls given callback on child nodes.
	Traverse(cb NodeVisitor) error
}

type NodeVisitor = func(n Node) error

type NotEqComparator[T comparable] struct{}

type NotMatcher[T any, M Matcher[T]] struct {
	Next M
}

type NumberLabelFilter[C Comparator[float64]] struct {
	// contains filtered or unexported fields
}

type Optimizer interface {
	// Name returns optimizer name.
	Name() string
	Optimize(ctx context.Context, q Query) (Query, error)
}

type Options struct {
	// LookbackDuration sets lookback duration for instant queries.
	//
	// Should be negative, otherwise default value would be used.
	LookbackDuration time.Duration

	// ParseOptions is a LogQL parser options.
	ParseOptions logql.ParseOptions

	// OTELAdapter enables 'otel adapter' whatever it is.
	OTELAdapter bool

	// Optimizers defines a list of optimiziers to use.
	Optimizers []Optimizer

	// MeterProvider provides OpenTelemetry meter for this engine.
	MeterProvider metric.MeterProvider

	// TracerProvider provides OpenTelemetry tracer for this engine.
	TracerProvider trace.TracerProvider
}

type OrLabelMatcher struct {
	Left  Processor
	Right Processor
}

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

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

type Pipeline struct {
	Stages []Processor
}

type PipelineNode interface {
	Node
	EvalPipeline(ctx context.Context, params EvalParams) (EntryIterator, error)
}

type PrefixIPMatcher struct {
	Prefix netip.Prefix
}

type Processor interface {
	Process(ts otelstorage.Timestamp, line string, labels logqlabels.LabelSet) (newLine string, keep bool)
}

type ProcessorNode struct {
	Input             PipelineNode
	Prefilter         Processor
	Selector          logql.Selector
	Pipeline          []logql.PipelineStage
	EnableOTELAdapter bool
}

type Querier interface {
	// Capabilities returns Querier capabilities.
	//
	// NOTE: engine would call once and then save value.
	// 	Capabilities should not change over time.
	Capabilities() QuerierCapabilities
	// Query creates new [PipelineNode].
	Query(ctx context.Context, selector []logql.LabelMatcher) (PipelineNode, error)
}

type QuerierCapabilities struct {
	Label SupportedOps
	Line  SupportedOps
}

type Query interface {
	Eval(ctx context.Context, params EvalParams) (lokiapi.QueryResponseData, error)
}

type RangeAggregation struct {
	Input SampleNode
	Expr  *logql.RangeAggregationExpr
}

type RangeIPMatcher struct {
	Range netipx.IPRange
}

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

type RegexpMatcher struct {
	Re *regexp.Regexp
}

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

type SampleIterator = iterators.Iterator[logqlmetric.SampledEntry]

type SampleNode interface {
	Node
	EvalSample(ctx context.Context, params EvalParams) (SampleIterator, error)
}

type SamplingNode struct {
	Input PipelineNode
	Expr  *logql.RangeAggregationExpr
}

type StepIterator = logqlmetric.StepIterator

type StringMatcher interface {
	Matcher[string]
}

type SupportedOps uint64

type UnpackExtractor struct{}

type Vector struct {
	Expr *logql.VectorExpr
}

type VectorAggregation struct {
	Input MetricNode
	Expr  *logql.VectorAggregationExpr
}