diff --git a/src/metrics/filters/tags_filter.go b/src/metrics/filters/tags_filter.go index 3f7eead844..434c7556cd 100644 --- a/src/metrics/filters/tags_filter.go +++ b/src/metrics/filters/tags_filter.go @@ -120,9 +120,6 @@ type TagsFilterOptions struct { // Function to extract name and tags from an id. NameAndTagsFn id.NameAndTagsFn - - // Function to create a new sorted tag iterator from id tags. - SortedTagIteratorFn id.SortedTagIteratorFn } // tagsFilter contains a list of tag filters. diff --git a/src/metrics/matcher/config.go b/src/metrics/matcher/config.go index 08d2dc85ec..9f39c6a2b0 100644 --- a/src/metrics/matcher/config.go +++ b/src/metrics/matcher/config.go @@ -31,7 +31,6 @@ import ( "github.com/m3db/m3/src/metrics/filters" "github.com/m3db/m3/src/metrics/matcher/cache" "github.com/m3db/m3/src/metrics/matcher/namespace" - "github.com/m3db/m3/src/metrics/metric/id" "github.com/m3db/m3/src/metrics/metric/id/m3" "github.com/m3db/m3/src/metrics/rules" "github.com/m3db/m3/src/x/clock" @@ -101,21 +100,9 @@ func (cfg *Configuration) NewOptions( } // Configure rules options. - scope := instrumentOpts.MetricsScope().SubScope("sorted-tag-iterator-pool") - poolOpts := cfg.SortedTagIteratorPool.NewObjectPoolOptions(instrumentOpts.SetMetricsScope(scope)) - sortedTagIteratorPool := id.NewSortedTagIteratorPool(poolOpts) - sortedTagIteratorPool.Init(func() id.SortedTagIterator { - return m3.NewPooledSortedTagIterator(nil, sortedTagIteratorPool) - }) - sortedTagIteratorFn := func(tagPairs []byte) id.SortedTagIterator { - it := sortedTagIteratorPool.Get() - it.Reset(tagPairs) - return it - } tagsFilterOptions := filters.TagsFilterOptions{ - NameTagKey: []byte(cfg.NameTagKey), - NameAndTagsFn: m3.NameAndTags, - SortedTagIteratorFn: sortedTagIteratorFn, + NameTagKey: []byte(cfg.NameTagKey), + NameAndTagsFn: m3.NameAndTags, } isRollupIDFn := func(name []byte, tags []byte) bool { diff --git a/src/metrics/matcher/match.go b/src/metrics/matcher/match.go index c8c2da3126..e5f1c825a4 100644 --- a/src/metrics/matcher/match.go +++ b/src/metrics/matcher/match.go @@ -102,16 +102,27 @@ func (m *matcher) ForwardMatch( func (m *matcher) ReverseMatch( id id.ID, - fromNanos, toNanos int64, + fromNanos int64, + toNanos int64, mt metric.Type, at aggregation.Type, isMultiAggregationTypesAllowed bool, aggTypesOpts aggregation.TypesOptions, + matchOpts rules.MatchOptions, ) (rules.MatchResult, error) { sw := m.metrics.matchLatency.Start() defer sw.Stop() // Cache does not support reverse matching. - return m.namespaces.ReverseMatch(id, fromNanos, toNanos, mt, at, isMultiAggregationTypesAllowed, aggTypesOpts) + return m.namespaces.ReverseMatch( + id, + fromNanos, + toNanos, + mt, + at, + isMultiAggregationTypesAllowed, + aggTypesOpts, + matchOpts, + ) } func (m *matcher) Close() error { @@ -156,15 +167,26 @@ func (m *noCacheMatcher) ForwardMatch( func (m *noCacheMatcher) ReverseMatch( id id.ID, - fromNanos, toNanos int64, + fromNanos int64, + toNanos int64, mt metric.Type, at aggregation.Type, isMultiAggregationTypesAllowed bool, aggTypesOpts aggregation.TypesOptions, + matchOpts rules.MatchOptions, ) (rules.MatchResult, error) { sw := m.metrics.matchLatency.Start() defer sw.Stop() - return m.namespaces.ReverseMatch(id, fromNanos, toNanos, mt, at, isMultiAggregationTypesAllowed, aggTypesOpts) + return m.namespaces.ReverseMatch( + id, + fromNanos, + toNanos, + mt, + at, + isMultiAggregationTypesAllowed, + aggTypesOpts, + matchOpts, + ) } func (m *noCacheMatcher) Close() error { diff --git a/src/metrics/matcher/matcher_mock.go b/src/metrics/matcher/matcher_mock.go index 0bab37ea5b..15557379fd 100644 --- a/src/metrics/matcher/matcher_mock.go +++ b/src/metrics/matcher/matcher_mock.go @@ -1,7 +1,7 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/m3db/m3/src/metrics/matcher (interfaces: Matcher) -// Copyright (c) 2022 Uber Technologies, Inc. +// Copyright (c) 2024 Uber Technologies, Inc. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal @@ -104,16 +104,16 @@ func (mr *MockMatcherMockRecorder) LatestRollupRules(arg0, arg1 interface{}) *go } // ReverseMatch mocks base method. -func (m *MockMatcher) ReverseMatch(arg0 id.ID, arg1, arg2 int64, arg3 metric.Type, arg4 aggregation.Type, arg5 bool, arg6 aggregation.TypesOptions) (rules.MatchResult, error) { +func (m *MockMatcher) ReverseMatch(arg0 id.ID, arg1, arg2 int64, arg3 metric.Type, arg4 aggregation.Type, arg5 bool, arg6 aggregation.TypesOptions, arg7 rules.MatchOptions) (rules.MatchResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReverseMatch", arg0, arg1, arg2, arg3, arg4, arg5, arg6) + ret := m.ctrl.Call(m, "ReverseMatch", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) ret0, _ := ret[0].(rules.MatchResult) ret1, _ := ret[1].(error) return ret0, ret1 } // ReverseMatch indicates an expected call of ReverseMatch. -func (mr *MockMatcherMockRecorder) ReverseMatch(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call { +func (mr *MockMatcherMockRecorder) ReverseMatch(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseMatch", reflect.TypeOf((*MockMatcher)(nil).ReverseMatch), arg0, arg1, arg2, arg3, arg4, arg5, arg6) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseMatch", reflect.TypeOf((*MockMatcher)(nil).ReverseMatch), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) } diff --git a/src/metrics/matcher/namespaces.go b/src/metrics/matcher/namespaces.go index 0b8dcae307..5f2503f511 100644 --- a/src/metrics/matcher/namespaces.go +++ b/src/metrics/matcher/namespaces.go @@ -202,18 +202,29 @@ func (n *namespaces) ForwardMatch(id id.ID, fromNanos, toNanos int64, func (n *namespaces) ReverseMatch( id id.ID, - fromNanos, toNanos int64, + fromNanos int64, + toNanos int64, mt metric.Type, at aggregation.Type, isMultiAggregationTypesAllowed bool, aggTypesOpts aggregation.TypesOptions, + matchOpts rules.MatchOptions, ) (rules.MatchResult, error) { namespace := n.nsResolver.Resolve(id) ruleSet, exists := n.ruleSet(namespace) if !exists { return rules.EmptyMatchResult, nil } - return ruleSet.ReverseMatch(id, fromNanos, toNanos, mt, at, isMultiAggregationTypesAllowed, aggTypesOpts) + return ruleSet.ReverseMatch( + id, + fromNanos, + toNanos, + mt, + at, + isMultiAggregationTypesAllowed, + aggTypesOpts, + matchOpts, + ) } func (n *namespaces) ruleSet(namespace []byte) (RuleSet, bool) { diff --git a/src/metrics/matcher/ruleset.go b/src/metrics/matcher/ruleset.go index b14a42d657..8a22fcfdc9 100644 --- a/src/metrics/matcher/ruleset.go +++ b/src/metrics/matcher/ruleset.go @@ -183,11 +183,13 @@ func (r *ruleSet) ForwardMatch(id id.ID, fromNanos, toNanos int64, opts rules.Ma func (r *ruleSet) ReverseMatch( id id.ID, - fromNanos, toNanos int64, + fromNanos int64, + toNanos int64, mt metric.Type, at aggregation.Type, isMultiAggregationTypesAllowed bool, aggTypesOpts aggregation.TypesOptions, + matchOpts rules.MatchOptions, ) (rules.MatchResult, error) { callStart := r.nowFn() r.RLock() @@ -196,7 +198,16 @@ func (r *ruleSet) ReverseMatch( r.metrics.nilMatcher.Inc(1) return rules.EmptyMatchResult, nil } - res, err := r.activeSet.ReverseMatch(id, fromNanos, toNanos, mt, at, isMultiAggregationTypesAllowed, aggTypesOpts) + res, err := r.activeSet.ReverseMatch( + id, + fromNanos, + toNanos, + mt, + at, + isMultiAggregationTypesAllowed, + aggTypesOpts, + matchOpts, + ) r.RUnlock() if err != nil { return rules.MatchResult{}, err diff --git a/src/metrics/matcher/ruleset_test.go b/src/metrics/matcher/ruleset_test.go index 2bbb487e73..5a21cebf73 100644 --- a/src/metrics/matcher/ruleset_test.go +++ b/src/metrics/matcher/ruleset_test.go @@ -100,8 +100,16 @@ func TestRuleSetReverseMatchWithMatcher(t *testing.T) { aggTypesOpts = aggregation.NewTypesOptions() ) - res, err := rs.ReverseMatch(testID("foo"), fromNanos, toNanos, metric.CounterType, aggregation.Sum, - isMultiAggregationTypesAllowed, aggTypesOpts) + res, err := rs.ReverseMatch( + testID("foo"), + fromNanos, + toNanos, + metric.CounterType, + aggregation.Sum, + isMultiAggregationTypesAllowed, + aggTypesOpts, + rules.MatchOptions{}, + ) require.NoError(t, err) require.Equal(t, mockMatcher.res, res) require.Equal(t, []byte("foo"), mockMatcher.id) @@ -148,11 +156,41 @@ func TestToRuleSetSuccess(t *testing.T) { func TestRuleSetProcessNamespaceNotRegistered(t *testing.T) { var ( inputs = []rules.RuleSet{ - &mockRuleSet{namespace: "ns1", version: 1, cutoverNanos: 1234, tombstoned: false, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns2", version: 2, cutoverNanos: 1235, tombstoned: true, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns3", version: 3, cutoverNanos: 1236, tombstoned: false, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns4", version: 4, cutoverNanos: 1237, tombstoned: true, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns5", version: 5, cutoverNanos: 1238, tombstoned: false, matcher: &mockMatcher{}}, + &mockRuleSet{ + namespace: "ns1", + version: 1, + cutoverNanos: 1234, + tombstoned: false, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns2", + version: 2, + cutoverNanos: 1235, + tombstoned: true, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns3", + version: 3, + cutoverNanos: 1236, + tombstoned: false, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns4", + version: 4, + cutoverNanos: 1237, + tombstoned: true, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns5", + version: 5, + cutoverNanos: 1238, + tombstoned: false, + matcher: &mockMatcher{}, + }, } ) @@ -173,11 +211,41 @@ func TestRuleSetProcessNamespaceNotRegistered(t *testing.T) { func TestRuleSetProcessStaleUpdate(t *testing.T) { var ( inputs = []rules.RuleSet{ - &mockRuleSet{namespace: "ns1", version: 1, cutoverNanos: 1234, tombstoned: false, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns2", version: 2, cutoverNanos: 1235, tombstoned: true, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns3", version: 3, cutoverNanos: 1236, tombstoned: false, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns4", version: 4, cutoverNanos: 1237, tombstoned: true, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns5", version: 5, cutoverNanos: 1238, tombstoned: false, matcher: &mockMatcher{}}, + &mockRuleSet{ + namespace: "ns1", + version: 1, + cutoverNanos: 1234, + tombstoned: false, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns2", + version: 2, + cutoverNanos: 1235, + tombstoned: true, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns3", + version: 3, + cutoverNanos: 1236, + tombstoned: false, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns4", + version: 4, + cutoverNanos: 1237, + tombstoned: true, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns5", + version: 5, + cutoverNanos: 1238, + tombstoned: false, + matcher: &mockMatcher{}, + }, } ) @@ -203,11 +271,41 @@ func TestRuleSetProcessStaleUpdate(t *testing.T) { func TestRuleSetProcessSuccess(t *testing.T) { var ( inputs = []rules.RuleSet{ - &mockRuleSet{namespace: "ns1", version: 1, cutoverNanos: 1234, tombstoned: false, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns2", version: 2, cutoverNanos: 1235, tombstoned: true, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns3", version: 3, cutoverNanos: 1236, tombstoned: false, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns4", version: 4, cutoverNanos: 1237, tombstoned: true, matcher: &mockMatcher{}}, - &mockRuleSet{namespace: "ns5", version: 5, cutoverNanos: 1238, tombstoned: false, matcher: &mockMatcher{}}, + &mockRuleSet{ + namespace: "ns1", + version: 1, + cutoverNanos: 1234, + tombstoned: false, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns2", + version: 2, + cutoverNanos: 1235, + tombstoned: true, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns3", + version: 3, + cutoverNanos: 1236, + tombstoned: false, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns4", + version: 4, + cutoverNanos: 1237, + tombstoned: true, + matcher: &mockMatcher{}, + }, + &mockRuleSet{ + namespace: "ns5", + version: 5, + cutoverNanos: 1238, + tombstoned: false, + matcher: &mockMatcher{}, + }, } ) @@ -261,11 +359,13 @@ func (mm *mockMatcher) ForwardMatch( func (mm *mockMatcher) ReverseMatch( id id.ID, - fromNanos, toNanos int64, + fromNanos int64, + toNanos int64, mt metric.Type, at aggregation.Type, isMultiAggregationTypesAllowed bool, aggTypesOpts aggregation.TypesOptions, + matchOpts rules.MatchOptions, ) (rules.MatchResult, error) { mm.id = id.Bytes() mm.fromNanos = fromNanos diff --git a/src/metrics/rules/active_ruleset.go b/src/metrics/rules/active_ruleset.go index 851f73b8cf..3df596b8ba 100644 --- a/src/metrics/rules/active_ruleset.go +++ b/src/metrics/rules/active_ruleset.go @@ -150,11 +150,13 @@ func (as *activeRuleSet) ForwardMatch( func (as *activeRuleSet) ReverseMatch( id metricid.ID, - fromNanos, toNanos int64, + fromNanos int64, + toNanos int64, mt metric.Type, at aggregation.Type, isMultiAggregationTypesAllowed bool, aggTypesOpts aggregation.TypesOptions, + matchOpts MatchOptions, ) (MatchResult, error) { var ( nextIdx = as.nextCutoverIdx(fromNanos) @@ -165,7 +167,7 @@ func (as *activeRuleSet) ReverseMatch( ) // Determine whether the ID is a rollup metric ID. - name, tags, err := as.tagsFilterOpts.NameAndTagsFn(id.Bytes()) + name, tags, err := matchOpts.NameAndTagsFn(id.Bytes()) if err == nil { isRollupID = as.isRollupIDFn(name, tags) } @@ -180,6 +182,7 @@ func (as *activeRuleSet) ReverseMatch( at, isMultiAggregationTypesAllowed, aggTypesOpts, + matchOpts, ) if err != nil { return MatchResult{}, err @@ -202,6 +205,7 @@ func (as *activeRuleSet) ReverseMatch( at, isMultiAggregationTypesAllowed, aggTypesOpts, + matchOpts, ) if err != nil { return MatchResult{}, err @@ -528,12 +532,12 @@ func (as *activeRuleSet) matchRollupTarget( var ( rollupTags = rollupOp.Tags - sortedTagIter = matchOpts.SortedTagIteratorFn(sortedTagPairBytes) matchTagIdx = 0 nameTagName = as.tagsFilterOpts.NameTagKey nameTagValue []byte includeTagNames = as.includeTagKeys ) + sortedTagIter := matchOpts.SortedTagIteratorFn(sortedTagPairBytes) switch rollupOp.Type { case mpipeline.GroupByRollupType: @@ -702,11 +706,21 @@ func (as *activeRuleSet) reverseMappingsFor( at aggregation.Type, isMultiAggregationTypesAllowed bool, aggTypesOpts aggregation.TypesOptions, + matchOpts MatchOptions, ) (reverseMatchResult, bool, error) { if !isRollupID { - return as.reverseMappingsForNonRollupID(id, timeNanos, mt, at, aggTypesOpts) + return as.reverseMappingsForNonRollupID(id, timeNanos, mt, at, aggTypesOpts, matchOpts) } - return as.reverseMappingsForRollupID(name, tags, timeNanos, mt, at, isMultiAggregationTypesAllowed, aggTypesOpts) + return as.reverseMappingsForRollupID( + name, + tags, + timeNanos, + mt, + at, + isMultiAggregationTypesAllowed, + aggTypesOpts, + matchOpts, + ) } type reverseMatchResult struct { @@ -722,11 +736,9 @@ func (as *activeRuleSet) reverseMappingsForNonRollupID( mt metric.Type, at aggregation.Type, aggTypesOpts aggregation.TypesOptions, + matchOpts MatchOptions, ) (reverseMatchResult, bool, error) { - mapping, err := as.mappingsForNonRollupID(id, timeNanos, MatchOptions{ - NameAndTagsFn: as.tagsFilterOpts.NameAndTagsFn, - SortedTagIteratorFn: as.tagsFilterOpts.SortedTagIteratorFn, - }) + mapping, err := as.mappingsForNonRollupID(id, timeNanos, matchOpts) if err != nil { return reverseMatchResult{}, false, err } @@ -763,12 +775,14 @@ func (as *activeRuleSet) reverseMappingsForNonRollupID( // we need to match the roll up tags, we also need to check the aggregation type against // each rollup pipeline to see if the aggregation type was actually contained in the pipeline. func (as *activeRuleSet) reverseMappingsForRollupID( - name, sortedTagPairBytes []byte, + name []byte, + sortedTagPairBytes []byte, timeNanos int64, mt metric.Type, at aggregation.Type, isMultiAggregationTypesAllowed bool, aggTypesOpts aggregation.TypesOptions, + matchOpts MatchOptions, ) (reverseMatchResult, bool, error) { for _, rollupRule := range as.rollupRules { snapshot := rollupRule.activeSnapshot(timeNanos) @@ -792,10 +806,7 @@ func (as *activeRuleSet) reverseMappingsForRollupID( nil, nil, matchRollupTargetOptions{generateRollupID: false}, - MatchOptions{ - NameAndTagsFn: as.tagsFilterOpts.NameAndTagsFn, - SortedTagIteratorFn: as.tagsFilterOpts.SortedTagIteratorFn, - }, + matchOpts, ) if err != nil { return reverseMatchResult{}, false, err diff --git a/src/metrics/rules/active_ruleset_bench_test.go b/src/metrics/rules/active_ruleset_bench_test.go index 047884a84e..da9f2540fc 100644 --- a/src/metrics/rules/active_ruleset_bench_test.go +++ b/src/metrics/rules/active_ruleset_bench_test.go @@ -50,10 +50,10 @@ func BenchmarkActiveRuleSet_ReverseMatch(b *testing.B) { b.Run(tc.name, func(b *testing.B) { b.ReportAllocs() - id := m3.NewID([]byte(tc.id), nil) + mid := m3.NewID([]byte(tc.id), nil) deps := setupActiveRuleSetBenchmark(b) - sanityCheckBenchmark(b, deps, id) + sanityCheckBenchmark(b, deps, mid) // N.B.: this is actually a heavy alloc, it turns out. typesOptions := aggregation.NewTypesOptions() @@ -63,7 +63,7 @@ func BenchmarkActiveRuleSet_ReverseMatch(b *testing.B) { var benchResult MatchResult for i := 0; i < b.N; i++ { r, _ := deps.RuleSet.ReverseMatch( - id, + mid, 0, // max int math.MaxInt64, @@ -71,6 +71,7 @@ func BenchmarkActiveRuleSet_ReverseMatch(b *testing.B) { aggregation.Sum, false, typesOptions, + deps.MatchOptions, ) benchResult = r } @@ -93,6 +94,7 @@ func TestActiveRuleSet_Benchmark(t *testing.T) { type ruleSetBenchmarkDeps struct { RuleSet *activeRuleSet + MatchOptions MatchOptions AggTypeOptions aggregation.TypesOptions } @@ -101,22 +103,33 @@ func setupActiveRuleSetBenchmark(t testing.TB) ruleSetBenchmarkDeps { mappingRules := newBenchmarkMappingRules(t, 20, 10) activeRules := newActiveRuleSet(0, mappingRules, rollupRules, filters.TagsFilterOptions{ - NameTagKey: []byte("name"), - NameAndTagsFn: m3.NameAndTags, - SortedTagIteratorFn: m3.NewSortedTagIterator, + NameTagKey: []byte("name"), + NameAndTagsFn: m3.NameAndTags, }, m3.NewRollupID, m3.IsRollupID, map[uint64]struct{}{}, ) + // We reuse the same iterator for each run. + iter := m3.NewSortedTagIterator(nil) + matchOpts := MatchOptions{ + NameAndTagsFn: m3.NameAndTags, + SortedTagIteratorFn: func(tags []byte) metricid.SortedTagIterator { + iter.Reset(tags) + return iter + }, + } + return ruleSetBenchmarkDeps{ RuleSet: activeRules, AggTypeOptions: aggregation.NewTypesOptions(), + MatchOptions: matchOpts, } } func sanityCheckBenchmark(t testing.TB, deps ruleSetBenchmarkDeps, id metricid.ID) { + matchResult, err := deps.RuleSet.ReverseMatch( id, 0, @@ -126,6 +139,7 @@ func sanityCheckBenchmark(t testing.TB, deps ruleSetBenchmarkDeps, id metricid.I aggregation.Sum, false, deps.AggTypeOptions, + deps.MatchOptions, ) require.NoError(t, err) @@ -175,9 +189,8 @@ func newBenchmarkMappingRuleSnapshot(t testing.TB) *mappingRuleSnapshot { }, filters.Conjunction, filters.TagsFilterOptions{ - NameTagKey: []byte("name"), - NameAndTagsFn: m3.NameAndTags, - SortedTagIteratorFn: m3.NewSortedTagIterator, + NameTagKey: []byte("name"), + NameAndTagsFn: m3.NameAndTags, }, ) require.NoError(t, err) diff --git a/src/metrics/rules/active_ruleset_test.go b/src/metrics/rules/active_ruleset_test.go index aa1bf731f1..cee33b224d 100644 --- a/src/metrics/rules/active_ruleset_test.go +++ b/src/metrics/rules/active_ruleset_test.go @@ -4202,8 +4202,16 @@ func TestActiveRuleSetReverseMatchWithMappingRulesForNonRollupID(t *testing.T) { for i, input := range inputs { input := input t.Run(fmt.Sprintf("input %d", i), func(t *testing.T) { - res, err := as.ReverseMatch(input.ID(), input.matchFrom, input.matchTo, - input.metricType, input.aggregationType, isMultiAggregationTypesAllowed, aggTypesOpts) + res, err := as.ReverseMatch( + input.ID(), + input.matchFrom, + input.matchTo, + input.metricType, + input.aggregationType, + isMultiAggregationTypesAllowed, + aggTypesOpts, + testMatchOptions(), + ) require.NoError(t, err) require.Equal(t, input.expireAtNanos, res.expireAtNanos) require.True(t, cmp.Equal(input.forExistingIDResult, res.ForExistingIDAt(0), testStagedMetadatasCmptOpts...)) @@ -4408,8 +4416,16 @@ func TestActiveRuleSetReverseMatchWithRollupRulesForRollupID(t *testing.T) { testIncludeTagKeys(), ) for _, input := range inputs { - res, err := as.ReverseMatch(input.ID(), input.matchFrom, input.matchTo, input.metricType, input.aggregationType, - isMultiAggregationTypesAllowed, aggTypesOpts) + res, err := as.ReverseMatch( + input.ID(), + input.matchFrom, + input.matchTo, + input.metricType, + input.aggregationType, + isMultiAggregationTypesAllowed, + aggTypesOpts, + testMatchOptions(), + ) require.NoError(t, err) require.Equal(t, input.expireAtNanos, res.expireAtNanos) require.Equal(t, input.forExistingIDResult, res.ForExistingIDAt(0)) diff --git a/src/metrics/rules/ruleset.go b/src/metrics/rules/ruleset.go index 29a0ef0b5f..a6acfef39d 100644 --- a/src/metrics/rules/ruleset.go +++ b/src/metrics/rules/ruleset.go @@ -74,11 +74,13 @@ type ReverseMatcher interface { // with aware of the metric type and aggregation type for the given id. ReverseMatch( id metricid.ID, - fromNanos, toNanos int64, + fromNanos int64, + toNanos int64, mt metric.Type, at aggregation.Type, isMultiAggregationTypesAllowed bool, aggTypesOpts aggregation.TypesOptions, + matchOpts MatchOptions, ) (MatchResult, error) } diff --git a/src/metrics/rules/ruleset_test.go b/src/metrics/rules/ruleset_test.go index 3324fdab9d..c309b2036c 100644 --- a/src/metrics/rules/ruleset_test.go +++ b/src/metrics/rules/ruleset_test.go @@ -2218,7 +2218,6 @@ func testTagsFilterOptions() filters.TagsFilterOptions { } return b[:idx], b[idx+1:], nil }, - SortedTagIteratorFn: filters.NewMockSortedTagIterator, } }