From 9ae98c48b99751c0e50a4a6d8885dc56b193299a Mon Sep 17 00:00:00 2001 From: Ben Ye Date: Mon, 4 Nov 2024 21:50:05 -0800 Subject: [PATCH 1/8] compatibility query fuzz test with results cache enabled Signed-off-by: Ben Ye --- integration/e2ecortex/client.go | 27 ++++- integration/query_fuzz_test.go | 176 ++++++++++++++++++++++++++++++-- 2 files changed, 196 insertions(+), 7 deletions(-) diff --git a/integration/e2ecortex/client.go b/integration/e2ecortex/client.go index 4ff4fa506aa..0d76da92709 100644 --- a/integration/e2ecortex/client.go +++ b/integration/e2ecortex/client.go @@ -59,11 +59,23 @@ func NewClient( alertmanagerAddress string, rulerAddress string, orgID string, +) (*Client, error) { + return NewClientWithByPassResultsCache(distributorAddress, querierAddress, alertmanagerAddress, rulerAddress, orgID, false) +} + +// NewClientWithByPassResultsCache makes a new Cortex client but allows to bypass query results cache if skipResultsCache set to true. +func NewClientWithByPassResultsCache( + distributorAddress string, + querierAddress string, + alertmanagerAddress string, + rulerAddress string, + orgID string, + skipResultsCache bool, ) (*Client, error) { // Create querier API client querierAPIClient, err := promapi.NewClient(promapi.Config{ Address: "http://" + querierAddress + "/api/prom", - RoundTripper: &addOrgIDRoundTripper{orgID: orgID, next: http.DefaultTransport}, + RoundTripper: &cacheControlRoundTripper{skipResultsCache: skipResultsCache, next: &addOrgIDRoundTripper{orgID: orgID, next: http.DefaultTransport}}, }) if err != nil { return nil, err @@ -587,6 +599,19 @@ func (r *addOrgIDRoundTripper) RoundTrip(req *http.Request) (*http.Response, err return r.next.RoundTrip(req) } +type cacheControlRoundTripper struct { + skipResultsCache bool + next http.RoundTripper +} + +func (r *cacheControlRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) { + if r.skipResultsCache { + req.Header.Set("Cache-Control", "no-store") + } + + return r.next.RoundTrip(req) +} + // ServerStatus represents a Alertmanager status response // TODO: Upgrade to Alertmanager v0.20.0+ and utilize vendored structs type ServerStatus struct { diff --git a/integration/query_fuzz_test.go b/integration/query_fuzz_test.go index a9d15a7ea96..4b9d72dea9c 100644 --- a/integration/query_fuzz_test.go +++ b/integration/query_fuzz_test.go @@ -29,6 +29,7 @@ import ( "github.com/thanos-io/thanos/pkg/store/storepb" "github.com/cortexproject/cortex/integration/e2e" + e2ecache "github.com/cortexproject/cortex/integration/e2e/cache" e2edb "github.com/cortexproject/cortex/integration/e2e/db" "github.com/cortexproject/cortex/integration/e2ecortex" "github.com/cortexproject/cortex/pkg/storage/bucket" @@ -143,7 +144,7 @@ func TestDisableChunkTrimmingFuzz(t *testing.T) { require.NoError(t, err) require.Equal(t, 200, res.StatusCode) - waitUntilReady(t, context.Background(), c1, c2, `{job="test"}`, start, now) + waitUntilBothServersReady(t, context.Background(), c1, c2, `{job="test"}`, start, now) rnd := rand.New(rand.NewSource(now.Unix())) opts := []promqlsmith.Option{ @@ -308,7 +309,7 @@ func TestVerticalShardingFuzz(t *testing.T) { require.NoError(t, err) require.Equal(t, 200, res.StatusCode) - waitUntilReady(t, context.Background(), c1, c2, `{job="test"}`, start, end) + waitUntilBothServersReady(t, context.Background(), c1, c2, `{job="test"}`, start, end) rnd := rand.New(rand.NewSource(now.Unix())) opts := []promqlsmith.Option{ @@ -858,7 +859,7 @@ func TestBackwardCompatibilityQueryFuzz(t *testing.T) { require.Equal(t, 200, res.StatusCode) ctx := context.Background() - waitUntilReady(t, ctx, c1, c2, `{job="test"}`, start, end) + waitUntilBothServersReady(t, ctx, c1, c2, `{job="test"}`, start, end) rnd := rand.New(rand.NewSource(now.Unix())) opts := []promqlsmith.Option{ @@ -972,7 +973,7 @@ func TestPrometheusCompatibilityQueryFuzz(t *testing.T) { c2, err := e2ecortex.NewPromQueryClient(prom.HTTPEndpoint()) require.NoError(t, err) - waitUntilReady(t, ctx, c1, c2, `{job="test"}`, start, end) + waitUntilBothServersReady(t, ctx, c1, c2, `{job="test"}`, start, end) opts := []promqlsmith.Option{ promqlsmith.WithEnableOffset(true), @@ -984,8 +985,171 @@ func TestPrometheusCompatibilityQueryFuzz(t *testing.T) { runQueryFuzzTestCases(t, ps, c1, c2, end, start, end, scrapeInterval, 100) } -// waitUntilReady is a helper function to wait and check if both servers to test load the expected data. -func waitUntilReady(t *testing.T, ctx context.Context, c1, c2 *e2ecortex.Client, query string, start, end time.Time) { +// TestResultsCacheBackwardCompatibilityQueryFuzz performs following steps: +// 1. Run a range query with time [start, start + 30m] against a Cortex container with previous release image. +// 2. Run the same range query with time [start, end] against a Cortex container with the latest image. It shares the same results cache with the previous container +// 3. Run the same range query with time [start, end] but with results cache bypassed and compare the query result got from last step. +func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { + // TODO: expose the image tag to be passed from Makefile or Github Action Config. + previousCortexReleaseImage := "quay.io/cortexproject/cortex:v1.18.1" + s, err := e2e.NewScenario(networkName) + require.NoError(t, err) + defer s.Close() + + // Start dependencies. + consul := e2edb.NewConsulWithName("consul") + memcached := e2ecache.NewMemcached() + require.NoError(t, s.StartAndWaitReady(consul, memcached)) + + flags := mergeFlags( + AlertmanagerLocalFlags(), + map[string]string{ + "-blocks-storage.tsdb.head-compaction-interval": "4m", + "-blocks-storage.tsdb.block-ranges-period": "2h", + "-blocks-storage.tsdb.ship-interval": "1h", + "-blocks-storage.bucket-store.sync-interval": "15m", + "-blocks-storage.tsdb.retention-period": "2h", + "-blocks-storage.bucket-store.index-cache.backend": tsdb.IndexCacheBackendInMemory, + "-querier.query-store-for-labels-enabled": "true", + // Ingester. + "-ring.store": "consul", + "-consul.hostname": consul.NetworkHTTPEndpoint(), + // Distributor. + "-distributor.replication-factor": "1", + // Store-gateway. + "-store-gateway.sharding-enabled": "false", + // alert manager + "-alertmanager.web.external-url": "http://localhost/alertmanager", + "-frontend.query-vertical-shard-size": "2", + "-frontend.max-cache-freshness": "1m", + // Enable results cache. + "-querier.cache-results": "true", + "-frontend.memcached.addresses": "dns+" + memcached.NetworkEndpoint(e2ecache.MemcachedPort), + }, + ) + // make alert manager config dir + require.NoError(t, writeFileToSharedDir(s, "alertmanager_configs", []byte{})) + + minio := e2edb.NewMinio(9000, flags["-blocks-storage.s3.bucket-name"]) + require.NoError(t, s.StartAndWaitReady(minio)) + + cortex1 := e2ecortex.NewSingleBinary("cortex-1", flags, previousCortexReleaseImage) + cortex2 := e2ecortex.NewSingleBinary("cortex-2", flags, "") + require.NoError(t, s.StartAndWaitReady(cortex1, cortex2)) + + // Wait until Cortex replicas have updated the ring state. + require.NoError(t, cortex1.WaitSumMetrics(e2e.Equals(float64(512)), "cortex_ring_tokens_total")) + require.NoError(t, cortex2.WaitSumMetrics(e2e.Equals(float64(512)), "cortex_ring_tokens_total")) + + // Check if we're discovering memcache or not. + require.NoError(t, cortex1.WaitSumMetrics(e2e.Equals(1), "cortex_memcache_client_servers")) + require.NoError(t, cortex2.WaitSumMetrics(e2e.Equals(1), "cortex_memcache_client_servers")) + + now := time.Now() + start := now.Add(-time.Hour * 2) + end := now.Add(-time.Hour) + numSeries := 10 + numSamples := 60 + lbls := make([]labels.Labels, 0, numSeries*2) + scrapeInterval := time.Minute + statusCodes := []string{"200", "400", "404", "500", "502"} + for i := 0; i < numSeries; i++ { + lbls = append(lbls, labels.Labels{ + {Name: labels.MetricName, Value: "test_series_a"}, + {Name: "job", Value: "test"}, + {Name: "series", Value: strconv.Itoa(i % 3)}, + {Name: "status_code", Value: statusCodes[i%5]}, + }) + + lbls = append(lbls, labels.Labels{ + {Name: labels.MetricName, Value: "test_series_b"}, + {Name: "job", Value: "test"}, + {Name: "series", Value: strconv.Itoa((i + 1) % 3)}, + {Name: "status_code", Value: statusCodes[(i+1)%5]}, + }) + } + + ctx := context.Background() + rnd := rand.New(rand.NewSource(time.Now().Unix())) + + dir := filepath.Join(s.SharedDir(), "data") + err = os.MkdirAll(dir, os.ModePerm) + require.NoError(t, err) + storage, err := e2ecortex.NewS3ClientForMinio(minio, flags["-blocks-storage.s3.bucket-name"]) + require.NoError(t, err) + bkt := bucket.NewUserBucketClient("user-1", storage.GetBucket(), nil) + id, err := e2e.CreateBlock(ctx, rnd, dir, lbls, numSamples, start.UnixMilli(), end.UnixMilli(), scrapeInterval.Milliseconds(), 10) + require.NoError(t, err) + err = block.Upload(ctx, log.Logger, bkt, filepath.Join(dir, id.String()), metadata.NoneFunc) + require.NoError(t, err) + + c1, err := e2ecortex.NewClient(cortex1.HTTPEndpoint(), cortex1.HTTPEndpoint(), "", "", "user-1") + require.NoError(t, err) + c2, err := e2ecortex.NewClientWithByPassResultsCache(cortex2.HTTPEndpoint(), cortex2.HTTPEndpoint(), "", "", "user-1", true) + require.NoError(t, err) + + waitUntilBothServersReady(t, context.Background(), c1, c2, `{job="test"}`, start, now) + + opts := []promqlsmith.Option{ + promqlsmith.WithEnableOffset(true), + promqlsmith.WithEnableAtModifier(true), + promqlsmith.WithEnabledFunctions(enabledFunctions), + } + ps := promqlsmith.New(rnd, lbls, opts...) + + type testCase struct { + query string + res1, res2 model.Value + err1, err2 error + } + + run := 1000 + cases := make([]*testCase, 0, run) + var ( + expr parser.Expr + query string + ) + for i := 0; i < run; i++ { + for { + expr = ps.WalkRangeQuery() + if isValidQuery(expr, 5) { + query = expr.Pretty(0) + break + } + } + // We don't care the query results here. Just to fill the cache with partial result. + _, _ = c1.QueryRange(query, start, start.Add(time.Minute*30), scrapeInterval) + cases = append(cases, &testCase{ + query: query, + }) + } + + for i := 0; i < run; i++ { + c := cases[i] + c.res1, c.err1 = c1.QueryRange(c.query, start, end, scrapeInterval) + c.res2, c.err2 = c2.QueryRange(c.query, start, end, scrapeInterval) + } + + failures := 0 + qt := "range query" + for i, tc := range cases { + if tc.err1 != nil || tc.err2 != nil { + if !cmp.Equal(tc.err1, tc.err2) { + t.Logf("case %d error mismatch.\n%s: %s\nerr1: %v\nerr2: %v\n", i, qt, tc.query, tc.err1, tc.err2) + failures++ + } + } else if !cmp.Equal(tc.res1, tc.res2, comparer) { + t.Logf("case %d results mismatch.\n%s: %s\nres1: %s\nres2: %s\n", i, qt, tc.query, tc.res1.String(), tc.res2.String()) + failures++ + } + } + if failures > 0 { + require.Failf(t, "finished query fuzzing tests", "%d test cases failed", failures) + } +} + +// waitUntilBothServersReady is a helper function to wait and check if both servers to test load the expected data. +func waitUntilBothServersReady(t *testing.T, ctx context.Context, c1, c2 *e2ecortex.Client, query string, start, end time.Time) { retries := backoff.New(ctx, backoff.Config{ MinBackoff: 5 * time.Second, MaxBackoff: 10 * time.Second, From 6ed815a14191afbeb95d6c522d935ab5eae4d08c Mon Sep 17 00:00:00 2001 From: Ben Ye Date: Tue, 5 Nov 2024 15:19:49 -0800 Subject: [PATCH 2/8] update test Signed-off-by: Ben Ye --- integration/query_fuzz_test.go | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/integration/query_fuzz_test.go b/integration/query_fuzz_test.go index 4b9d72dea9c..9f118cc35b6 100644 --- a/integration/query_fuzz_test.go +++ b/integration/query_fuzz_test.go @@ -986,8 +986,8 @@ func TestPrometheusCompatibilityQueryFuzz(t *testing.T) { } // TestResultsCacheBackwardCompatibilityQueryFuzz performs following steps: -// 1. Run a range query with time [start, start + 30m] against a Cortex container with previous release image. -// 2. Run the same range query with time [start, end] against a Cortex container with the latest image. It shares the same results cache with the previous container +// 1. Run a range query with time [start, start + 30m] against a Cortex container with previous release image to fill results cache. +// 2. Run the same range query with time [start, end] against a Cortex container with the latest image. // 3. Run the same range query with time [start, end] but with results cache bypassed and compare the query result got from last step. func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { // TODO: expose the image tag to be passed from Makefile or Github Action Config. @@ -1085,7 +1085,9 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { c1, err := e2ecortex.NewClient(cortex1.HTTPEndpoint(), cortex1.HTTPEndpoint(), "", "", "user-1") require.NoError(t, err) - c2, err := e2ecortex.NewClientWithByPassResultsCache(cortex2.HTTPEndpoint(), cortex2.HTTPEndpoint(), "", "", "user-1", true) + c2, err := e2ecortex.NewClient(cortex2.HTTPEndpoint(), cortex2.HTTPEndpoint(), "", "", "user-1") + require.NoError(t, err) + c2ByPassCache, err := e2ecortex.NewClientWithByPassResultsCache(cortex2.HTTPEndpoint(), cortex2.HTTPEndpoint(), "", "", "user-1", true) require.NoError(t, err) waitUntilBothServersReady(t, context.Background(), c1, c2, `{job="test"}`, start, now) @@ -1126,8 +1128,9 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { for i := 0; i < run; i++ { c := cases[i] - c.res1, c.err1 = c1.QueryRange(c.query, start, end, scrapeInterval) - c.res2, c.err2 = c2.QueryRange(c.query, start, end, scrapeInterval) + // If not bypassing cache, we expect this query to fetch part of the query results as well as reusing some existing cached result. + c.res1, c.err1 = c2.QueryRange(c.query, start, end, scrapeInterval) + c.res2, c.err2 = c2ByPassCache.QueryRange(c.query, start, end, scrapeInterval) } failures := 0 From 41f321e817f6a3a2f31ba5983aa5d252223a7093 Mon Sep 17 00:00:00 2001 From: Ben Ye Date: Tue, 5 Nov 2024 16:22:11 -0800 Subject: [PATCH 3/8] fix qfe cache flag Signed-off-by: Ben Ye --- integration/query_fuzz_test.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/integration/query_fuzz_test.go b/integration/query_fuzz_test.go index 9f118cc35b6..e8101115ab4 100644 --- a/integration/query_fuzz_test.go +++ b/integration/query_fuzz_test.go @@ -1023,8 +1023,9 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { "-frontend.query-vertical-shard-size": "2", "-frontend.max-cache-freshness": "1m", // Enable results cache. - "-querier.cache-results": "true", - "-frontend.memcached.addresses": "dns+" + memcached.NetworkEndpoint(e2ecache.MemcachedPort), + "-querier.cache-results": "true", + "-querier.split-queries-by-interval": "24h", + "-frontend.memcached.addresses": "dns+" + memcached.NetworkEndpoint(e2ecache.MemcachedPort), }, ) // make alert manager config dir From fd96b9288ee7e2ba6c55008f50ae68873bcc6783 Mon Sep 17 00:00:00 2001 From: Ben Ye Date: Tue, 5 Nov 2024 18:46:43 -0800 Subject: [PATCH 4/8] fix flag Signed-off-by: Ben Ye --- integration/query_fuzz_test.go | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/integration/query_fuzz_test.go b/integration/query_fuzz_test.go index e8101115ab4..1c5c88ff5da 100644 --- a/integration/query_fuzz_test.go +++ b/integration/query_fuzz_test.go @@ -997,23 +997,24 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { defer s.Close() // Start dependencies. - consul := e2edb.NewConsulWithName("consul") + consul1 := e2edb.NewConsulWithName("consul-1") + consul2 := e2edb.NewConsulWithName("consul-2") memcached := e2ecache.NewMemcached() - require.NoError(t, s.StartAndWaitReady(consul, memcached)) + require.NoError(t, s.StartAndWaitReady(consul1, consul2, memcached)) + baseFlags := mergeFlags(AlertmanagerLocalFlags(), BlocksStorageFlags()) flags := mergeFlags( - AlertmanagerLocalFlags(), + baseFlags, map[string]string{ "-blocks-storage.tsdb.head-compaction-interval": "4m", "-blocks-storage.tsdb.block-ranges-period": "2h", "-blocks-storage.tsdb.ship-interval": "1h", - "-blocks-storage.bucket-store.sync-interval": "15m", - "-blocks-storage.tsdb.retention-period": "2h", + "-blocks-storage.bucket-store.sync-interval": "1s", + "-blocks-storage.tsdb.retention-period": "24h", "-blocks-storage.bucket-store.index-cache.backend": tsdb.IndexCacheBackendInMemory, "-querier.query-store-for-labels-enabled": "true", // Ingester. - "-ring.store": "consul", - "-consul.hostname": consul.NetworkHTTPEndpoint(), + "-ring.store": "consul", // Distributor. "-distributor.replication-factor": "1", // Store-gateway. @@ -1028,14 +1029,20 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { "-frontend.memcached.addresses": "dns+" + memcached.NetworkEndpoint(e2ecache.MemcachedPort), }, ) + flags1 := mergeFlags(flags, map[string]string{ + "-consul.hostname": consul1.NetworkHTTPEndpoint(), + }) + flags2 := mergeFlags(flags, map[string]string{ + "-consul.hostname": consul2.NetworkHTTPEndpoint(), + }) // make alert manager config dir require.NoError(t, writeFileToSharedDir(s, "alertmanager_configs", []byte{})) minio := e2edb.NewMinio(9000, flags["-blocks-storage.s3.bucket-name"]) require.NoError(t, s.StartAndWaitReady(minio)) - cortex1 := e2ecortex.NewSingleBinary("cortex-1", flags, previousCortexReleaseImage) - cortex2 := e2ecortex.NewSingleBinary("cortex-2", flags, "") + cortex1 := e2ecortex.NewSingleBinary("cortex-1", flags1, previousCortexReleaseImage) + cortex2 := e2ecortex.NewSingleBinary("cortex-2", flags2, "") require.NoError(t, s.StartAndWaitReady(cortex1, cortex2)) // Wait until Cortex replicas have updated the ring state. From 5f7dfc0dd05d0163a490eea1f10017ff2e6ed9d3 Mon Sep 17 00:00:00 2001 From: Ben Ye Date: Tue, 5 Nov 2024 20:04:00 -0800 Subject: [PATCH 5/8] increase query step Signed-off-by: Ben Ye --- integration/query_fuzz_test.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/integration/query_fuzz_test.go b/integration/query_fuzz_test.go index 1c5c88ff5da..04b14fc603e 100644 --- a/integration/query_fuzz_test.go +++ b/integration/query_fuzz_test.go @@ -1114,6 +1114,7 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { } run := 1000 + step := 5 * time.Minute cases := make([]*testCase, 0, run) var ( expr parser.Expr @@ -1128,7 +1129,7 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { } } // We don't care the query results here. Just to fill the cache with partial result. - _, _ = c1.QueryRange(query, start, start.Add(time.Minute*30), scrapeInterval) + _, _ = c1.QueryRange(query, start, start.Add(time.Minute*30), step) cases = append(cases, &testCase{ query: query, }) @@ -1137,8 +1138,8 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { for i := 0; i < run; i++ { c := cases[i] // If not bypassing cache, we expect this query to fetch part of the query results as well as reusing some existing cached result. - c.res1, c.err1 = c2.QueryRange(c.query, start, end, scrapeInterval) - c.res2, c.err2 = c2ByPassCache.QueryRange(c.query, start, end, scrapeInterval) + c.res1, c.err1 = c2.QueryRange(c.query, start, end, step) + c.res2, c.err2 = c2ByPassCache.QueryRange(c.query, start, end, step) } failures := 0 From bdcb99f4a5c8e1ba81aacbe58200a331e8f0bc13 Mon Sep 17 00:00:00 2001 From: Ben Ye Date: Tue, 5 Nov 2024 20:06:00 -0800 Subject: [PATCH 6/8] reduce runs Signed-off-by: Ben Ye --- integration/query_fuzz_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/integration/query_fuzz_test.go b/integration/query_fuzz_test.go index 04b14fc603e..ede0869adef 100644 --- a/integration/query_fuzz_test.go +++ b/integration/query_fuzz_test.go @@ -1113,7 +1113,7 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { err1, err2 error } - run := 1000 + run := 100 step := 5 * time.Minute cases := make([]*testCase, 0, run) var ( From 3a348e8fbc3ae2b2974d89f7da96d26e1f5bb492 Mon Sep 17 00:00:00 2001 From: Ben Ye Date: Tue, 5 Nov 2024 21:14:37 -0800 Subject: [PATCH 7/8] increase query time range in first attempt Signed-off-by: Ben Ye --- integration/query_fuzz_test.go | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/integration/query_fuzz_test.go b/integration/query_fuzz_test.go index ede0869adef..d667753a8bd 100644 --- a/integration/query_fuzz_test.go +++ b/integration/query_fuzz_test.go @@ -1042,7 +1042,7 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { require.NoError(t, s.StartAndWaitReady(minio)) cortex1 := e2ecortex.NewSingleBinary("cortex-1", flags1, previousCortexReleaseImage) - cortex2 := e2ecortex.NewSingleBinary("cortex-2", flags2, "") + cortex2 := e2ecortex.NewSingleBinary("cortex-2", flags2, "yeya24/cortex:disable-chunk-trimming-0663e40bc-arm64") require.NoError(t, s.StartAndWaitReady(cortex1, cortex2)) // Wait until Cortex replicas have updated the ring state. @@ -1091,11 +1091,11 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { err = block.Upload(ctx, log.Logger, bkt, filepath.Join(dir, id.String()), metadata.NoneFunc) require.NoError(t, err) - c1, err := e2ecortex.NewClient(cortex1.HTTPEndpoint(), cortex1.HTTPEndpoint(), "", "", "user-1") + c1, err := e2ecortex.NewClient("", cortex1.HTTPEndpoint(), "", "", "user-1") require.NoError(t, err) - c2, err := e2ecortex.NewClient(cortex2.HTTPEndpoint(), cortex2.HTTPEndpoint(), "", "", "user-1") + c2, err := e2ecortex.NewClient("", cortex2.HTTPEndpoint(), "", "", "user-1") require.NoError(t, err) - c2ByPassCache, err := e2ecortex.NewClientWithByPassResultsCache(cortex2.HTTPEndpoint(), cortex2.HTTPEndpoint(), "", "", "user-1", true) + c2ByPassCache, err := e2ecortex.NewClientWithByPassResultsCache("", cortex2.HTTPEndpoint(), "", "", "user-1", true) require.NoError(t, err) waitUntilBothServersReady(t, context.Background(), c1, c2, `{job="test"}`, start, now) @@ -1108,9 +1108,9 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { ps := promqlsmith.New(rnd, lbls, opts...) type testCase struct { - query string - res1, res2 model.Value - err1, err2 error + query string + res1, res2, res3 model.Value + err1, err2, err3 error } run := 100 @@ -1129,17 +1129,16 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { } } // We don't care the query results here. Just to fill the cache with partial result. - _, _ = c1.QueryRange(query, start, start.Add(time.Minute*30), step) + _, _ = c1.QueryRange(query, start.Add(-2*step), start.Add(time.Minute*30), step) cases = append(cases, &testCase{ query: query, }) } for i := 0; i < run; i++ { - c := cases[i] // If not bypassing cache, we expect this query to fetch part of the query results as well as reusing some existing cached result. - c.res1, c.err1 = c2.QueryRange(c.query, start, end, step) - c.res2, c.err2 = c2ByPassCache.QueryRange(c.query, start, end, step) + cases[i].res1, cases[i].err1 = c2.QueryRange(cases[i].query, start, end, step) + cases[i].res2, cases[i].err2 = c2ByPassCache.QueryRange(cases[i].query, start, end, step) } failures := 0 From 358f8e0a0abbc89d9af53b08bf9603bc2c1f17e0 Mon Sep 17 00:00:00 2001 From: Ben Ye Date: Tue, 5 Nov 2024 21:25:58 -0800 Subject: [PATCH 8/8] fix lint Signed-off-by: Ben Ye --- integration/query_fuzz_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/integration/query_fuzz_test.go b/integration/query_fuzz_test.go index d667753a8bd..8fe68b59a0f 100644 --- a/integration/query_fuzz_test.go +++ b/integration/query_fuzz_test.go @@ -1108,9 +1108,9 @@ func TestResultsCacheBackwardCompatibilityQueryFuzz(t *testing.T) { ps := promqlsmith.New(rnd, lbls, opts...) type testCase struct { - query string - res1, res2, res3 model.Value - err1, err2, err3 error + query string + res1, res2 model.Value + err1, err2 error } run := 100