Clone filterer of label filter (#11514)

pkg/logql/log/label_filter.go

@@ -366,7 +366,7 @@ func NewStringLabelFilter(m *labels.Matcher) LabelFilterer {
 
 	return &LineFilterLabelFilter{
 		Matcher: m,
-		filter:  f,
+		Filter:  f,
 	}
 }
 
@@ -383,12 +383,12 @@ func (s *StringLabelFilter) RequiredLabelNames() []string {
 // LineFilterLabelFilter filters the desired label using an optimized line filter
 type LineFilterLabelFilter struct {
 	*labels.Matcher
-	filter Filterer
+	Filter Filterer
 }
 
 // overrides the matcher.String() function in case there is a regexpFilter
 func (s *LineFilterLabelFilter) String() string {
-	if unwrappedFilter, ok := s.filter.(regexpFilter); ok {
+	if unwrappedFilter, ok := s.Filter.(regexpFilter); ok {
 		rStr := unwrappedFilter.String()
 		str := fmt.Sprintf("%s%s`%s`", s.Matcher.Name, s.Matcher.Type, rStr)
 		return str
@@ -398,7 +398,7 @@ func (s *LineFilterLabelFilter) String() string {
 
 func (s *LineFilterLabelFilter) Process(_ int64, line []byte, lbs *LabelsBuilder) ([]byte, bool) {
 	v := labelValue(s.Name, lbs)
-	return line, s.filter.Filter(unsafeGetBytes(v))
+	return line, s.Filter.Filter(unsafeGetBytes(v))
 }
 
 func (s *LineFilterLabelFilter) isLabelFilterer() {}

pkg/logql/syntax/clone.go

@@ -230,7 +230,9 @@ func cloneLabelFilterer(filter log.LabelFilterer) log.LabelFilterer {
 		}
 		return copied
 	case *log.LineFilterLabelFilter:
-		copied := &log.LineFilterLabelFilter{}
+		copied := &log.LineFilterLabelFilter{
+			Filter: concrete.Filter,
+		}
 		if concrete.Matcher != nil {
 			copied.Matcher = mustNewMatcher(concrete.Type, concrete.Name, concrete.Value)
 		}

pkg/logql/syntax/clone_test.go

@@ -81,17 +81,35 @@ func TestClone(t *testing.T) {
 }
 
 func TestCloneStringLabelFilter(t *testing.T) {
-	expr := newPipelineExpr(
+	for name, tc := range map[string]struct {
-		newMatcherExpr([]*labels.Matcher{mustNewMatcher(labels.MatchEqual, "foo", "bar")}),
+		expr Expr
-		MultiStageExpr{
+	}{
-			newLogfmtParserExpr(nil),
+		"pipeline": {
-			newLabelFilterExpr(&log.StringLabelFilter{Matcher: labels.MustNewMatcher(labels.MatchEqual, "foo", "bar")}),
+			expr: newPipelineExpr(
-		},
+				newMatcherExpr([]*labels.Matcher{mustNewMatcher(labels.MatchEqual, "foo", "bar")}),
-	)
+				MultiStageExpr{
-	actual, err := Clone[Expr](expr)
+					newLogfmtParserExpr(nil),
-	require.NoError(t, err)
+					newLabelFilterExpr(&log.StringLabelFilter{Matcher: labels.MustNewMatcher(labels.MatchEqual, "foo", "bar")}),
+				},
+			),
+		},
+		"filterer": {
+			expr: &LabelFilterExpr{
+				LabelFilterer: &log.LineFilterLabelFilter{
+					Matcher: mustNewMatcher(labels.MatchEqual, "foo", "bar"),
+					Filter:  log.ExistsFilter,
+				},
+			},
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			actual, err := Clone[Expr](tc.expr)
+			require.NoError(t, err)
 
-	require.Equal(t, expr.Pretty(0), actual.Pretty(0))
+			require.Equal(t, tc.expr.Pretty(0), actual.Pretty(0))
+			require.Equal(t, tc.expr, actual)
+		})
+	}
 }
 
 func TestCloneParseTestCases(t *testing.T) {