Add tracql support for ancestor and parent operator

CHANGELOG.md

@@ -1,4 +1,5 @@
 ## main / unreleased
+* [FEATURE] New TraceQL structural operators ancestor (<<), parent (<) [#2877](https://github.com/grafana/tempo/pull/2877) (@kousikmitra)
 * [ENHANCEMENT] Add support for searching by span status message using  `statusMessage` keyword [#2848](https://github.com/grafana/tempo/pull/2848) (@kousikmitra)
 * [FEATURE] Add the `/api/status/buildinfo` endpoint [#2702](https://github.com/grafana/tempo/pull/2702) (@fabrizio-grafana)
 * [FEATURE] New encoding vParquet3 with support for dedicated attribute columns (@mapno, @stoewer) [#2649](https://github.com/grafana/tempo/pull/2649)

docs/sources/tempo/traceql/_index.md

@@ -211,7 +211,9 @@ The second expression returns no traces because it's impossible for a single spa
 These spanset operators look at the structure of a trace and the relationship between the spans.
 
 - `{condA} >> {condB}` - The descendant operator (`>>`) looks for spans matching `{condB}` that are descendants of a span matching `{condA}`
+- `{condA} << {condB}` - The ancestor operator (`<<`) looks for spans matching `{condB}` that are ancestor of a span matching `{condA}`
 - `{condA} > {condB}` - The child operator (`>`) looks for spans matching `{condB}` that are direct child spans of a parent matching `{condA}`
+- `{condA} > {condB}` - The parent operator (`<`) looks for spans matching `{condB}` that are direct parent spans of a child matching `{condA}`
 - `{condA} ~ {condB}` - The sibling operator (`~`) checks that spans matching `{condA}` and `{condB}` are siblings of the same parent span.
 
 For example, to find a trace where a specific HTTP API interacted with a specific database:

pkg/traceql/ast.go

@@ -241,10 +241,18 @@ func (o SpansetOperation) extractConditions(request *FetchSpansRequest) {
 		request.Conditions = append(request.Conditions, Condition{
 			Attribute: NewIntrinsic(IntrinsicStructuralDescendant),
 		})
+	case OpSpansetAncestor:
+		request.Conditions = append(request.Conditions, Condition{
+			Attribute: NewIntrinsic(IntrinsicStructuralDescendant),
+		})
 	case OpSpansetChild:
 		request.Conditions = append(request.Conditions, Condition{
 			Attribute: NewIntrinsic(IntrinsicStructuralChild),
 		})
+	case OpSpansetParent:
+		request.Conditions = append(request.Conditions, Condition{
+			Attribute: NewIntrinsic(IntrinsicStructuralParent),
+		})
 	case OpSpansetSibling:
 		request.Conditions = append(request.Conditions, Condition{
 			Attribute: NewIntrinsic(IntrinsicStructuralSibling),

pkg/traceql/ast_execute.go

@@ -116,6 +116,23 @@ func (o SpansetOperation) evaluate(input []*Spanset) (output []*Spanset, err err
 				output = append(output, matchingSpanset)
 			}
 
+		case OpSpansetAncestor:
+			spans, err := o.joinSpansets(lhs, rhs, func(l, r Span) bool {
+				// In case of ancestor the lhs becomes descendant of rhs
+				return l.DescendantOf(r)
+			})
+			if err != nil {
+				return nil, err
+			}
+
+			if len(spans) > 0 {
+				// Clone here to capture previously computed aggregates, grouped attrs, etc.
+				// Copy spans to new slice because of internal buffering.
+				matchingSpanset := input[i].clone()
+				matchingSpanset.Spans = append([]Span(nil), spans...)
+				output = append(output, matchingSpanset)
+			}
+
 		case OpSpansetChild:
 			spans, err := o.joinSpansets(lhs, rhs, func(l, r Span) bool {
 				return r.ChildOf(l)
@@ -132,6 +149,23 @@ func (o SpansetOperation) evaluate(input []*Spanset) (output []*Spanset, err err
 				output = append(output, matchingSpanset)
 			}
 
+		case OpSpansetParent:
+			spans, err := o.joinSpansets(lhs, rhs, func(l, r Span) bool {
+				// In case of parent the lhs becomes child of rhs
+				return l.ChildOf(r)
+			})
+			if err != nil {
+				return nil, err
+			}
+
+			if len(spans) > 0 {
+				// Clone here to capture previously computed aggregates, grouped attrs, etc.
+				// Copy spans to new slice because of internal buffering.
+				matchingSpanset := input[i].clone()
+				matchingSpanset.Spans = append([]Span(nil), spans...)
+				output = append(output, matchingSpanset)
+			}
+
 		case OpSpansetSibling:
 			spans, err := o.joinSpansets(lhs, rhs, func(l, r Span) bool {
 				return r.SiblingOf(l)

pkg/traceql/ast_execute_test.go

@@ -359,6 +359,20 @@ func TestSpansetOperationEvaluate(t *testing.T) {
 				}},
 			},
 		},
+		{
+			"{ .child } << { .parent }",
+			[]*Spanset{
+				{Spans: []Span{
+					newMockSpan([]byte{1}).WithAttrBool("parent", true).WithNestedSetInfo(0, 1, 4),
+					newMockSpan([]byte{1}).WithAttrBool("child", true).WithNestedSetInfo(1, 2, 3),
+				}},
+			},
+			[]*Spanset{
+				{Spans: []Span{
+					newMockSpan([]byte{1}).WithAttrBool("parent", true).WithNestedSetInfo(0, 1, 4),
+				}},
+			},
+		},
 		{
 			"{ .parent } > { .child }",
 			[]*Spanset{
@@ -373,6 +387,20 @@ func TestSpansetOperationEvaluate(t *testing.T) {
 				}},
 			},
 		},
+		{
+			"{ .child } < { .parent }",
+			[]*Spanset{
+				{Spans: []Span{
+					newMockSpan([]byte{1}).WithAttrBool("parent", true).WithNestedSetInfo(0, 1, 4),
+					newMockSpan([]byte{1}).WithAttrBool("child", true).WithNestedSetInfo(1, 2, 3),
+				}},
+			},
+			[]*Spanset{
+				{Spans: []Span{
+					newMockSpan([]byte{1}).WithAttrBool("parent", true).WithNestedSetInfo(0, 1, 4),
+				}},
+			},
+		},
 		{
 			"{ .child1 } ~ { .child2 }",
 			[]*Spanset{
@@ -397,6 +425,16 @@ func TestSpansetOperationEvaluate(t *testing.T) {
 			},
 			[]*Spanset{},
 		},
+		{ // tests that parent operators do not modify the spanset
+			"{ } < { } < { } < { }",
+			[]*Spanset{
+				{Spans: []Span{
+					newMockSpan([]byte{1}).WithAttrBool("parent1", true).WithNestedSetInfo(1, 2, 3),
+					newMockSpan([]byte{1}).WithAttrBool("parent2", true).WithNestedSetInfo(1, 4, 5),
+				}},
+			},
+			[]*Spanset{},
+		},
 	}
 
 	for _, tc := range testCases {

pkg/traceql/ast_validate.go

@@ -181,7 +181,9 @@ func (o BinaryOperation) validate() error {
 
 	switch o.Op {
 	case OpSpansetChild,
+		OpSpansetParent,
 		OpSpansetDescendant,
+		OpSpansetAncestor,
 		OpSpansetSibling:
 		return newUnsupportedError(fmt.Sprintf("binary operation (%v)", o.Op))
 	}

pkg/traceql/enum_attributes.go

@@ -64,11 +64,13 @@ const (
 
 	// These intrinsics do not map to specific data points, but are used to
 	// indicate that Spans must be able to answer the structural methods
-	// DescdendantOf, SiblingOf, and ChildOf.  The details of those methods
+	// DescdendantOf, AncestorOf, SiblingOf, ChildOf and ParentOf.  The details of those methods
 	// and how these intrinsics are handled is left to the implementation.
 	IntrinsicStructuralDescendant
+	IntrinsicStructuralAncestor
 	IntrinsicStructuralSibling
 	IntrinsicStructuralChild
+	IntrinsicStructuralParent
 
 	// not yet implemented in traceql and may never be. these exist so that we can retrieve
 	// these fields from the fetch layer

pkg/traceql/enum_operators.go

@@ -24,7 +24,9 @@ const (
 	OpOr
 	OpNot
 	OpSpansetChild
+	OpSpansetParent
 	OpSpansetDescendant
+	OpSpansetAncestor
 	OpSpansetAnd
 	OpSpansetUnion
 	OpSpansetSibling
@@ -149,8 +151,12 @@ func (op Operator) String() string {
 		return "!"
 	case OpSpansetChild:
 		return ">"
+	case OpSpansetParent:
+		return "<"
 	case OpSpansetDescendant:
 		return ">>"
+	case OpSpansetAncestor:
+		return "<<"
 	case OpSpansetAnd:
 		return "&&"
 	case OpSpansetSibling:

pkg/traceql/enum_operators_test.go

@@ -29,7 +29,9 @@ func TestOperatorIsBoolean(t *testing.T) {
 		{OpOr, true},
 		{OpNot, true},
 		{OpSpansetChild, false},
+		{OpSpansetParent, false},
 		{OpSpansetDescendant, false},
+		{OpSpansetAncestor, false},
 		{OpSpansetAnd, false},
 		{OpSpansetUnion, false},
 		{OpSpansetSibling, false},
@@ -140,7 +142,9 @@ func TestOperatorUnaryTypesValid(t *testing.T) {
 		{OpAnd, TypeInt, false},
 		{OpOr, TypeInt, false},
 		{OpSpansetChild, TypeInt, false},
+		{OpSpansetParent, TypeInt, false},
 		{OpSpansetDescendant, TypeInt, false},
+		{OpSpansetAncestor, TypeInt, false},
 		{OpSpansetAnd, TypeInt, false},
 		{OpSpansetUnion, TypeInt, false},
 		{OpSpansetSibling, TypeInt, false},

pkg/traceql/expr.y

@@ -84,7 +84,7 @@ import (
 // Operators are listed with increasing precedence.
 %left <binOp> PIPE
 %left <binOp> AND OR
-%left <binOp> EQ NEQ LT LTE GT GTE NRE RE DESC TILDE
+%left <binOp> EQ NEQ LT LTE GT GTE NRE RE DESC ANCE TILDE
 %left <binOp> ADD SUB
 %left <binOp> NOT
 %left <binOp> MUL DIV MOD
@@ -107,7 +107,9 @@ spansetPipelineExpression: // shares the same operators as spansetExpression. sp
     OPEN_PARENS spansetPipelineExpression CLOSE_PARENS           { $$ = $2 }
   | spansetPipelineExpression AND   spansetPipelineExpression    { $$ = newSpansetOperation(OpSpansetAnd, $1, $3) }
   | spansetPipelineExpression GT    spansetPipelineExpression    { $$ = newSpansetOperation(OpSpansetChild, $1, $3) }
+  | spansetPipelineExpression LT    spansetPipelineExpression    { $$ = newSpansetOperation(OpSpansetParent, $1, $3) }
   | spansetPipelineExpression DESC  spansetPipelineExpression    { $$ = newSpansetOperation(OpSpansetDescendant, $1, $3) }
+  | spansetPipelineExpression ANCE  spansetPipelineExpression    { $$ = newSpansetOperation(OpSpansetAncestor, $1, $3) }
   | spansetPipelineExpression OR    spansetPipelineExpression    { $$ = newSpansetOperation(OpSpansetUnion, $1, $3) }
   | spansetPipelineExpression TILDE spansetPipelineExpression    { $$ = newSpansetOperation(OpSpansetSibling, $1, $3) }
   | wrappedSpansetPipeline                                       { $$ = $1 }
@@ -149,7 +151,9 @@ spansetExpression: // shares the same operators as scalarPipelineExpression. spl
     OPEN_PARENS spansetExpression CLOSE_PARENS   { $$ = $2 }
   | spansetExpression AND   spansetExpression    { $$ = newSpansetOperation(OpSpansetAnd, $1, $3) }
   | spansetExpression GT    spansetExpression    { $$ = newSpansetOperation(OpSpansetChild, $1, $3) }
+  | spansetExpression LT    spansetExpression    { $$ = newSpansetOperation(OpSpansetParent, $1, $3) }
   | spansetExpression DESC  spansetExpression    { $$ = newSpansetOperation(OpSpansetDescendant, $1, $3) }
+  | spansetExpression ANCE  spansetExpression    { $$ = newSpansetOperation(OpSpansetAncestor, $1, $3) }
   | spansetExpression OR    spansetExpression    { $$ = newSpansetOperation(OpSpansetUnion, $1, $3) }
   | spansetExpression TILDE spansetExpression    { $$ = newSpansetOperation(OpSpansetSibling, $1, $3) }
   | spansetFilter                                { $$ = $1 }