traceql

type ASTRewriter interface {
	RewriteRoot(*RootExpr) *RootExpr
}

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

type AggregateMode int

type AggregateOp int

type Attribute struct {
	Name      string         // 16 bytes
	Scope     AttributeScope // 1 byte - aligned with other fields
	Parent    bool           // 1 byte - aligned with other fields
	Intrinsic Intrinsic      // 1 byte - aligned with other fields
}

type AttributeScope int8

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

type BinaryOperation struct {
	Op  Operator
	LHS FieldExpression
	RHS FieldExpression
	// contains filtered or unexported fields
}

type ChainedSecondStage []secondStageElement

type CoalesceOperation struct{}

type CommonIterator[T any] interface {
	Next(context.Context) (T, error)
	Close()
}

type CompileOption func(*compileOptions)

type Condition struct {
	Attribute Attribute
	Op        Operator
	Operands  Operands
	// Callback is used in the parquetquery.CallbackPredicate to determine if the iterator should be stopped.
	// It's used to limit the overhead of fetching exemplars by stopping the iterator early.
	CallBack func() bool

	// Hints
	Precision time.Duration
}

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

type Element interface {
	fmt.Stringer
	// contains filtered or unexported methods
}

type Engine struct{}

type Exemplar struct {
	Labels      Labels
	Value       float64
	TimestampMs uint64
}

type FastStatic interface {
	FastStatic1 | FastStatic2 | FastStatic3 | FastStatic4 | FastStatic5
}

type FastStatic1 [1]StaticMapKey

type FastStatic2 [2]StaticMapKey

type FastStatic3 [3]StaticMapKey

type FastStatic4 [4]StaticMapKey

type FastStatic5 [5]StaticMapKey

type FetchSpansOnlyResponse struct {
	Results SpanIterator
	// callback to get the size of data read during Fetch
	Bytes func() uint64
}

type FetchSpansRequest struct {
	StartTimeUnixNanos uint64
	EndTimeUnixNanos   uint64
	Conditions         []Condition

	// By default, the storage layer fetches spans meeting any of the criteria.
	// This hint is for common cases like { x && y && z } where the storage layer
	// can make extra optimizations by returning only spansets that meet
	// all criteria.
	AllConditions bool

	// Sampling
	// There are two methods of sampling: trace-level samples a subset of traces,
	// either skipping them or returning them in full.  Span-level samples a
	// subset of spans within each trace, still returning a spanset for each
	// matching trace. Only one will be applied at a time.  These fields are
	// optional and there is no negative effect on the results if they are not
	// honored at the storage layer.
	TraceSampler Sampler
	SpanSampler  Sampler

	// SecondPassFn and Conditions allow a caller to retrieve one set of data
	// in the first pass, filter using the SecondPassFn callback and then
	// request a different set of data in the second pass. This is particularly
	// useful for retrieving data required to resolve a TraceQL query in the first
	// pass and only selecting metadata in the second pass.
	// TODO: extend this to an arbitrary number of passes
	SecondPass           SecondPassFn
	SecondPassConditions []Condition
	SecondPassSelectAll  bool // Ignore second pass conditions and select all attributes
}

type FetchSpansResponse struct {
	Results SpansetIterator
	// callback to get the size of data read during Fetch
	Bytes func() uint64
}

type FetchTagValuesCallback func(static Static) bool

type FetchTagValuesRequest struct {
	ConditionGroups [][]Condition
	TagName         Attribute
}

type FetchTagsCallback func(tag string, scope AttributeScope) bool

type FetchTagsRequest struct {
	ConditionGroups [][]Condition
	Scope           AttributeScope
}

type FieldExpression interface {
	Element
	// contains filtered or unexported methods
}

type GroupOperation struct {
	Expression FieldExpression
	// contains filtered or unexported fields
}

type GroupingAggregator[F FastStatic, S StaticVals] struct {
	// contains filtered or unexported fields
}

type Hint struct {
	Name  string
	Value Static
}

type Hints struct {
	Hints []*Hint
}

type Histogram struct {
	Buckets []HistogramBucket
}

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

type HistogramBucket struct {
	Max   float64
	Count int
}

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

type IntervalMapper interface {
	// Interval the given timestamp within the range and step.
	Interval(ts uint64) int
	// IntervalMs is the same as Bucket except the input and calculations are in unix milliseconds.
	IntervalMs(ts int64) int
	TimestampOf(interval int) uint64
	// IntervalCount is the number of intervals in the range with step.
	IntervalCount() int
}

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

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

type Intrinsic int8

type Kind int

type Label struct {
	Name  string
	Value Static
}

type Labels []Label

type MetadataCombiner interface {
	AddMetadata(*tempopb.TraceSearchMetadata) bool
	IsCompleteFor(ts uint32) bool

	Metadata() []*tempopb.TraceSearchMetadata
	MetadataAfter(ts uint32) []*tempopb.TraceSearchMetadata
	// contains filtered or unexported methods
}

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

type MetricsAggregateOp int

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

type MetricsEvaluator interface {
	Do(ctx context.Context, f SpansetFetcher, fetcherStart, fetcherEnd uint64, maxSeries int) error
	Length() int
	Metrics() (uint64, uint64, uint64)
	Results() SeriesSet
}

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

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

type Operands []Static

type Operator int

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

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

type Pipeline struct {
	Elements []PipelineElement
}

type PipelineElement interface {
	Element
	// contains filtered or unexported methods
}

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

type RangeAggregator interface {
	Observe(s Span)
	ObserveExemplar(float64, uint64, Labels)
	Samples() []float64
	Exemplars() []Exemplar
	Length() int
}

type RootExpr struct {
	Pipeline           map[string]Pipeline        // spanset filters
	BatchSpanProcessor map[string]spanProcessor   // span processing
	SeriesProcessor    map[string]seriesProcessor // time series processing

	Hints             *Hints
	OptimizationCount int
	// contains filtered or unexported fields
}

type Sampler interface {
	// Sample is called on every entry. If this returns true the entry should
	// be inspected further. If this returns false then the entry should be skipped.
	Sample() bool

	// Measured is called on matching data coming into the TraceQL engine.
	// This is how samplers gain knowledge of the actual proportion of data matching the query.
	Measured()

	// Expect is called before any sampling and provides knowledge of the total number of entries
	// that are present in the dataset. This allows the sampler to alter behavior if needed.
	Expect(count uint64)

	// FinalScalingFactor is called at the end to and is how much to scale up the
	// results.
	FinalScalingFactor() float64
}

type ScalarExpression interface {
	// PipelineElement
	Element
	// contains filtered or unexported methods
}

type ScalarFilter struct {
	Op  Operator
	LHS ScalarExpression
	RHS ScalarExpression
}

type ScalarOperation struct {
	Op  Operator
	LHS ScalarExpression
	RHS ScalarExpression
}

type SecondPassFn func(*Spanset) ([]*Spanset, error)

type SecondStageOp int

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

type SeriesAggregator interface {
	Combine([]*tempopb.TimeSeries)
	Results() SeriesSet
	Length() int
}

type SeriesMapKey [maxGroupBys]SeriesMapLabel

type SeriesMapLabel struct {
	Name  string
	Value StaticMapKey
}

type SeriesSet map[SeriesMapKey]TimeSeries

type ServiceStats struct {
	SpanCount  uint32
	ErrorCount uint32
}

type SimpleAggregationOp int

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

type Span interface {
	// AttributeFor returns the attribute for the given key. If the attribute is not found then
	// the second return value will be false.
	AttributeFor(Attribute) (Static, bool)
	// AllAttributes returns a map of all attributes for this span. AllAttributes should be used sparingly
	// and is expected to be significantly slower than AttributeFor.
	AllAttributes() map[Attribute]Static
	// AllAttributesFunc is a way to access all attributes for this span, letting the span determine the
	// optimal method. Avoids allocating a map like AllAttributes.
	AllAttributesFunc(func(Attribute, Static))

	ID() []byte
	StartTimeUnixNanos() uint64
	DurationNanos() uint64

	// SiblingOf returns all spans on the RHS side that have siblings in the LHS. If falseForAll is true
	// then the returned spans will be those that do not have siblings in the LHS. buffer is an optional
	// buffer to use to avoid allocations.
	SiblingOf(lhs []Span, rhs []Span, falseForAll bool, union bool, buffer []Span) []Span
	// DescendantOf returns all spans on the RHS side that have descendants in the LHS. If falseForAll is true
	// then the returned spans will be those that do not have descendants in the LHS. invert is used to invert
	// the relationship. If invert is true then this will behave like "AncestorOf". buffer is an optional
	// buffer to use to avoid allocations.
	DescendantOf(lhs []Span, rhs []Span, falseForAll bool, invert bool, union bool, buffer []Span) []Span
	// ChildOf returns all spans on the RHS side that have children in the LHS. If falseForAll is true
	// then the returned spans will be those that do not have children in the LHS. invert is used to invert
	// the relationship. If invert is true then this will behave like "ParentOf". buffer is an optional
	// buffer to use to avoid allocations.
	ChildOf(lhs []Span, rhs []Span, falseForAll bool, invert bool, union bool, buffer []Span) []Span
}

type SpanAggregator interface {
	Observe(Span)
	ObserveExemplar(Span, float64, uint64)
	Series() SeriesSet
	Length() int
}

type SpanIterator interface {
	CommonIterator[Span]
}

type Spanset struct {
	// these fields are actually used by the engine to evaluate queries
	Scalar Static
	Spans  []Span

	TraceID            []byte
	RootSpanName       string
	RootServiceName    string
	StartTimeUnixNanos uint64
	DurationNanos      uint64
	ServiceStats       map[string]ServiceStats
	Attributes         []*SpansetAttribute

	// Set this function to provide upstream callers with a method to
	// release this spanset and all its spans when finished. This method will be
	// called with the spanset itself as the argument. This is done for a worthwhile
	// memory savings as the same function pointer can then be reused across spansets.
	ReleaseFn func(*Spanset)
}

type SpansetAttribute struct {
	Name string
	Val  Static
}

type SpansetExpression interface {
	PipelineElement
	// contains filtered or unexported methods
}

type SpansetFetcher interface {
	Fetch(context.Context, FetchSpansRequest) (FetchSpansResponse, error)
	FetchSpans(context.Context, FetchSpansRequest) (FetchSpansOnlyResponse, error)
}

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

type SpansetFilter struct {
	Expression FieldExpression
	// contains filtered or unexported fields
}

type SpansetFilterFunc func(input []*Spanset) (result []*Spanset, err error)

type SpansetIterator interface {
	CommonIterator[*Spanset]
}

type SpansetOperation struct {
	Op  Operator
	LHS SpansetExpression
	RHS SpansetExpression
	// contains filtered or unexported fields
}

type Static struct {
	Type StaticType
	// contains filtered or unexported fields
}

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

type StaticType int

type StaticVals interface {
	StaticVals1 | StaticVals2 | StaticVals3 | StaticVals4 | StaticVals5
}

type StaticVals1 [1]Static

type StaticVals2 [2]Static

type StaticVals3 [3]Static

type StaticVals4 [4]Static

type StaticVals5 [5]Static

type Status int

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

type TagNamesFetcher interface {
	Fetch(context.Context, FetchTagsRequest, FetchTagsCallback) error
}

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

type TagValuesFetcher interface {
	Fetch(context.Context, FetchTagValuesRequest, FetchTagValuesCallback) error
}

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

type TimeSeries struct {
	Labels    Labels
	Values    []float64
	Exemplars []Exemplar
}

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

type UnaryOperation struct {
	Op         Operator
	Expression FieldExpression
}

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

type VectorAggregator interface {
	Observe(s Span)
	Sample() float64
}