fix(querier): Support multi-tenant queries in Patterns API (#19809)

Co-authored-by: Trevor Whitney <[email protected]>

Author: paulojmdias

pkg/querier/http.go

@@ -471,15 +471,23 @@ func (q *QuerierAPI) PatternsHandler(ctx context.Context, req *logproto.QueryPat
 	}
 
 	// Query store for older data by converting to LogQL query
-	// Only query the store if pattern persistence is enabled for this tenant
+	// Only query the store if pattern persistence is enabled for at least one tenant
 	if storeQueryInterval != nil && !q.cfg.QueryIngesterOnly && q.engineV1 != nil {
-		tenantID, err := tenant.TenantID(ctx)
+		tenantIDs, err := tenant.TenantIDs(ctx)
 		if err != nil {
 			return nil, err
 		}
 
-		// Only query the store if pattern persistence is enabled for this tenant
-		if q.limits.PatternPersistenceEnabled(tenantID) {
+		// Only query the store if pattern persistence is enabled for at least one tenant
+		patternPersistenceEnabled := false
+		for _, tenantID := range tenantIDs {
+			if q.limits.PatternPersistenceEnabled(tenantID) {
+				patternPersistenceEnabled = true
+				break
+			}
+		}
+
+		if patternPersistenceEnabled {
 			g.Go(func() error {
 				storeReq := *req
 				storeReq.Start = storeQueryInterval.start

pkg/querier/multi_tenant_querier.go

@@ -6,6 +6,7 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/grafana/loki/v3/pkg/querier/pattern"
 	"github.com/grafana/loki/v3/pkg/querier/plan"
 	"github.com/grafana/loki/v3/pkg/storage/detected"
 	"github.com/grafana/loki/v3/pkg/storage/stores/index/seriesvolume"
@@ -289,6 +290,32 @@ func (q *MultiTenantQuerier) Volume(ctx context.Context, req *logproto.VolumeReq
 	return merged, nil
 }
 
+func (q *MultiTenantQuerier) Patterns(ctx context.Context, req *logproto.QueryPatternsRequest) (*logproto.QueryPatternsResponse, error) {
+	tenantIDs, err := tenant.TenantIDs(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(tenantIDs) == 1 {
+		return q.Querier.Patterns(ctx, req)
+	}
+
+	responses := make([]*logproto.QueryPatternsResponse, len(tenantIDs))
+	for i, id := range tenantIDs {
+		singleContext := user.InjectOrgID(ctx, id)
+		resp, err := q.Querier.Patterns(singleContext, req)
+		if err != nil {
+			return nil, err
+		}
+
+		responses[i] = resp
+	}
+
+	// Merge pattern responses from all tenants
+	merged := pattern.MergePatternResponses(responses)
+	return merged, nil
+}
+
 func (q *MultiTenantQuerier) DetectedFields(ctx context.Context, req *logproto.DetectedFieldsRequest) (*logproto.DetectedFieldsResponse, error) {
 	tenantIDs, err := tenant.TenantIDs(ctx)
 	if err != nil {

pkg/querier/multi_tenant_querier_test.go

@@ -708,3 +708,84 @@ func TestMultiTenantQuerier_DetectedLabels(t *testing.T) {
 		})
 	}
 }
+
+func TestMultiTenantQuerierPatterns(t *testing.T) {
+	now := time.Now()
+
+	tests := []struct {
+		name              string
+		orgID             string
+		expectedCallCount int // number of times underlying Patterns should be called
+		expectedPatterns  []string
+	}{
+		{
+			name:              "single tenant",
+			orgID:             "tenant1",
+			expectedCallCount: 1,
+			expectedPatterns:  []string{"pattern1", "pattern2"},
+		},
+		{
+			name:              "multiple tenants",
+			orgID:             "tenant1|tenant2",
+			expectedCallCount: 2,
+			expectedPatterns:  []string{"pattern1", "pattern2"}, // merged from both tenants
+		},
+		{
+			name:              "three tenants",
+			orgID:             "tenant1|tenant2|tenant3",
+			expectedCallCount: 3,
+			expectedPatterns:  []string{"pattern1", "pattern2"},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			querier := newQuerierMock()
+
+			// Mock the Patterns method to return a response
+			querier.On("Patterns", mock.Anything, mock.Anything).Return(&logproto.QueryPatternsResponse{
+				Series: []*logproto.PatternSeries{
+					{
+						Pattern: "pattern1",
+						Samples: []*logproto.PatternSample{
+							{Timestamp: 0, Value: 100},
+						},
+					},
+					{
+						Pattern: "pattern2",
+						Samples: []*logproto.PatternSample{
+							{Timestamp: 0, Value: 50},
+						},
+					},
+				},
+			}, nil)
+
+			multiTenantQuerier := NewMultiTenantQuerier(querier, log.NewNopLogger())
+			ctx := user.InjectOrgID(context.Background(), tc.orgID)
+
+			req := &logproto.QueryPatternsRequest{
+				Query: `{service_name="test"}`,
+				Start: now.Add(-1 * time.Hour),
+				End:   now,
+				Step:  time.Minute.Milliseconds(),
+			}
+
+			resp, err := multiTenantQuerier.Patterns(ctx, req)
+			require.NoError(t, err)
+			require.NotNil(t, resp)
+
+			// Verify the underlying Patterns was called the expected number of times
+			querier.AssertNumberOfCalls(t, "Patterns", tc.expectedCallCount)
+
+			// Verify we got the expected patterns
+			require.Len(t, resp.Series, len(tc.expectedPatterns))
+			foundPatterns := make(map[string]bool)
+			for _, series := range resp.Series {
+				foundPatterns[series.Pattern] = true
+			}
+			for _, expectedPattern := range tc.expectedPatterns {
+				require.True(t, foundPatterns[expectedPattern], "Expected pattern %s not found", expectedPattern)
+			}
+		})
+	}
+}