Update features endpoint to use Prometheus format

Refactored the GET /api/v1/features endpoint to return the standard
Prometheus nested map format (map[string]map[string]bool) instead of
a flat string slice. This aligns the discovery endpoint with Prometheus's
client expectations.

- Removed Cortex-specific features (e.g. parquet_queryable)
- Dynamically build promql_functions from the parser
- Updated unit tests and the handler JSON encoder

Signed-off-by: Ayush Kumar <kayush2k02@gmail.com>

Author: ayushkcs

pkg/api/api.go

@@ -86,9 +86,9 @@ type Config struct {
 
 	QuerierDefaultCodec string `yaml:"querier_default_codec"`
 
-	// Features is a list of enabled feature names to be exposed via the /api/v1/features endpoint.
-	// This is injected by the upstream caller.
-	Features []string `yaml:"-"`
+	// Features is a map of feature categories to their feature flags, matching the Prometheus
+	// features.json format. This is injected by the upstream caller.
+	Features map[string]map[string]bool `yaml:"-"`
 }
 
 var (

pkg/api/handlers.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"html/template"
@@ -396,29 +397,33 @@ func (h *buildInfoHandler) ServeHTTP(writer http.ResponseWriter, _ *http.Request
 }
 
 type featuresHandler struct {
-	features []string
+	features map[string]map[string]bool
 	logger   log.Logger
 }
 
 type featuresResponse struct {
-	Status string   `json:"status"`
-	Data   []string `json:"data"`
+	Status string                       `json:"status"`
+	Data   map[string]map[string]bool   `json:"data"`
 }
 
 func (h *featuresHandler) ServeHTTP(writer http.ResponseWriter, _ *http.Request) {
 	resp := featuresResponse{
 		Status: "success",
 		Data:   h.features,
 	}
-	output, err := json.Marshal(resp)
-	if err != nil {
+	// Use a non-HTML-escaping encoder to avoid escaping PromQL operators
+	// like >=, <=, etc., matching the Prometheus features endpoint behavior.
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(resp); err != nil {
 		level.Error(h.logger).Log("msg", "marshal features response", "error", err)
 		http.Error(writer, err.Error(), http.StatusInternalServerError)
 		return
 	}
 	writer.Header().Set("Content-Type", "application/json")
 	writer.WriteHeader(http.StatusOK)
-	if _, err := writer.Write(output); err != nil {
+	if _, err := writer.Write(buf.Bytes()); err != nil {
 		level.Error(h.logger).Log("msg", "write features response", "error", err)
 	}
 }

pkg/api/handlers_test.go

@@ -253,28 +253,30 @@ func TestBuildInfoAPI(t *testing.T) {
 
 func TestFeaturesAPI(t *testing.T) {
 	for _, tc := range []struct {
-		name             string
-		features         []string
-		expectedStatus   int
-		expectedFeatures []string
+		name     string
+		features map[string]map[string]bool
 	}{
 		{
-			name:             "no features enabled",
-			features:         nil,
-			expectedStatus:   200,
-			expectedFeatures: nil,
-		},
-		{
-			name:             "single feature enabled",
-			features:         []string{"remote_write_v2"},
-			expectedStatus:   200,
-			expectedFeatures: []string{"remote_write_v2"},
+			name:     "nil features",
+			features: nil,
 		},
 		{
-			name:             "multiple features enabled",
-			features:         []string{"remote_write_v2", "streaming_ingestion", "parquet_queryable", "tenant_federation"},
-			expectedStatus:   200,
-			expectedFeatures: []string{"remote_write_v2", "streaming_ingestion", "parquet_queryable", "tenant_federation"},
+			name: "populated features",
+			features: map[string]map[string]bool{
+				"api": {
+					"query_stats":        true,
+					"label_values_match": true,
+				},
+				"promql_operators": {
+					">=": true,
+					"<=": true,
+				},
+				"promql_functions": {
+					"abs":   true,
+					"ceil":  true,
+					"floor": true,
+				},
+			},
 		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
@@ -287,14 +289,41 @@ func TestFeaturesAPI(t *testing.T) {
 			req := httptest.NewRequest("GET", "/api/v1/features", nil)
 			handler.ServeHTTP(writer, req)
 
-			assert.Equal(t, tc.expectedStatus, writer.Code)
+			assert.Equal(t, 200, writer.Code)
 			assert.Equal(t, "application/json", writer.Header().Get("Content-Type"))
 
 			var resp featuresResponse
 			err := json.Unmarshal(writer.Body.Bytes(), &resp)
 			require.NoError(t, err)
 			assert.Equal(t, "success", resp.Status)
-			assert.Equal(t, tc.expectedFeatures, resp.Data)
+
+			if tc.features == nil {
+				assert.Nil(t, resp.Data)
+			} else {
+				require.NotNil(t, resp.Data)
+				for category, featureMap := range tc.features {
+					assert.Equal(t, featureMap, resp.Data[category], "category %s mismatch", category)
+				}
+			}
 		})
 	}
+
+	// Verify that PromQL operators like >= and <= are NOT HTML-escaped.
+	t.Run("operators not html escaped", func(t *testing.T) {
+		handler := &featuresHandler{
+			features: map[string]map[string]bool{
+				"promql_operators": {">=": true, "<=": true},
+			},
+			logger: &FakeLogger{},
+		}
+		writer := httptest.NewRecorder()
+		req := httptest.NewRequest("GET", "/api/v1/features", nil)
+		handler.ServeHTTP(writer, req)
+
+		body := writer.Body.String()
+		assert.Contains(t, body, `">="`)
+		assert.Contains(t, body, `"<="`)
+		assert.NotContains(t, body, `\u003e`)
+		assert.NotContains(t, body, `\u003c`)
+	})
 }

pkg/cortex/modules.go

@@ -18,6 +18,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/promql"
+	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/rules"
 	prom_storage "github.com/prometheus/prometheus/storage"
 	"github.com/thanos-io/objstore"
@@ -127,30 +128,61 @@ func (t *Cortex) initAPI() (services.Service, error) {
 	return nil, nil
 }
 
-// cortexFeatures returns a list of feature names that are enabled in the given config.
-func cortexFeatures(cfg Config) []string {
-	var features []string
-
-	if cfg.Distributor.RemoteWriteV2Enabled {
-		features = append(features, "remote_write_v2")
-	}
-	if cfg.Distributor.UseStreamPush {
-		features = append(features, "streaming_ingestion")
-	}
-	if cfg.Querier.EnableParquetQueryable {
-		features = append(features, "parquet_queryable")
-	}
-	if cfg.TenantFederation.Enabled {
-		features = append(features, "tenant_federation")
+// cortexFeatures returns a Prometheus-compatible features map based on the given config.
+// The response format matches Prometheus's GET /api/v1/features endpoint, providing
+// clients like Grafana with accurate capability discovery.
+func cortexFeatures(cfg Config) map[string]map[string]bool {
+	features := make(map[string]map[string]bool)
+
+	experimentalFunctions := cfg.Querier.EnablePromQLExperimentalFunctions
+
+	// Build promql_functions from the vendored Prometheus parser.
+	promqlFunctions := make(map[string]bool, len(parser.Functions))
+	for name, fn := range parser.Functions {
+		if fn.Experimental {
+			promqlFunctions[name] = experimentalFunctions
+		} else {
+			promqlFunctions[name] = true
+		}
 	}
-	if cfg.Querier.DistributedExecEnabled {
-		features = append(features, "distributed_execution")
+	features["promql_functions"] = promqlFunctions
+
+	// PromQL language features supported by Cortex.
+	features["promql"] = map[string]bool{
+		"at_modifier":     true,
+		"negative_offset": true,
+		"offset":          true,
+		"subqueries":      true,
+		"bool":            true,
+		"by":              true,
+		"without":         true,
+		"on":              true,
+		"ignoring":        true,
+		"group_left":      true,
+		"group_right":     true,
+		"per_step_stats":  cfg.Querier.EnablePerStepStats,
 	}
-	if cfg.Querier.EnablePromQLExperimentalFunctions {
-		features = append(features, "promql_experimental_functions")
+
+	// PromQL operators supported by Cortex.
+	features["promql_operators"] = map[string]bool{
+		"+": true, "-": true, "*": true, "/": true, "%": true, "^": true,
+		"==": true, "!=": true, ">": true, "<": true, ">=": true, "<=": true,
+		"=~": true, "!~": true, "@": true,
+		"and": true, "or": true, "unless": true,
+		"sum": true, "avg": true, "count": true, "min": true, "max": true,
+		"group": true, "stddev": true, "stdvar": true,
+		"topk": true, "bottomk": true, "count_values": true, "quantile": true,
+		"atan2": true,
+		"limitk":      false,
+		"limit_ratio": false,
 	}
-	if cfg.API.BuildInfoEnabled() {
-		features = append(features, "build_info")
+
+	// API features relevant to Cortex as a Prometheus-compatible query backend.
+	features["api"] = map[string]bool{
+		"query_stats":        cfg.Querier.EnablePerStepStats,
+		"label_values_match": true,
+		"time_range_labels":  true,
+		"time_range_series":  true,
 	}
 
 	return features

pkg/cortex/modules_test.go

@@ -356,66 +356,25 @@ func setAllSecrets(v reflect.Value, sentinel string) {
 
 func TestCortexFeatures(t *testing.T) {
 	tests := []struct {
-		name             string
-		configFn         func(*Config)
-		expectedFeatures []string
+		name                 string
+		configFn             func(*Config)
+		experimentalExpected bool
+		queryStatsExpected   bool
 	}{
 		{
-			name:             "no features enabled",
-			configFn:         func(cfg *Config) {},
-			expectedFeatures: nil,
+			name:                 "default features",
+			configFn:             func(cfg *Config) {},
+			experimentalExpected: false,
+			queryStatsExpected:   false,
 		},
 		{
-			name: "remote_write_v2 enabled",
-			configFn: func(cfg *Config) {
-				cfg.Distributor.RemoteWriteV2Enabled = true
-			},
-			expectedFeatures: []string{"remote_write_v2"},
-		},
-		{
-			name: "streaming_ingestion enabled",
-			configFn: func(cfg *Config) {
-				cfg.Distributor.UseStreamPush = true
-			},
-			expectedFeatures: []string{"streaming_ingestion"},
-		},
-		{
-			name: "parquet_queryable enabled",
-			configFn: func(cfg *Config) {
-				cfg.Querier.EnableParquetQueryable = true
-			},
-			expectedFeatures: []string{"parquet_queryable"},
-		},
-		{
-			name: "tenant_federation enabled",
-			configFn: func(cfg *Config) {
-				cfg.TenantFederation.Enabled = true
-			},
-			expectedFeatures: []string{"tenant_federation"},
-		},
-		{
-			name: "distributed_execution enabled",
-			configFn: func(cfg *Config) {
-				cfg.Querier.DistributedExecEnabled = true
-			},
-			expectedFeatures: []string{"distributed_execution"},
-		},
-		{
-			name: "promql_experimental_functions enabled",
+			name: "experimental functions and query stats enabled",
 			configFn: func(cfg *Config) {
 				cfg.Querier.EnablePromQLExperimentalFunctions = true
+				cfg.Querier.EnablePerStepStats = true
 			},
-			expectedFeatures: []string{"promql_experimental_functions"},
-		},
-		{
-			name: "multiple features enabled",
-			configFn: func(cfg *Config) {
-				cfg.Distributor.RemoteWriteV2Enabled = true
-				cfg.Distributor.UseStreamPush = true
-				cfg.TenantFederation.Enabled = true
-				cfg.Querier.EnableParquetQueryable = true
-			},
-			expectedFeatures: []string{"remote_write_v2", "streaming_ingestion", "parquet_queryable", "tenant_federation"},
+			experimentalExpected: true,
+			queryStatsExpected:   true,
 		},
 	}
 
@@ -424,7 +383,27 @@ func TestCortexFeatures(t *testing.T) {
 			cfg := Config{}
 			tc.configFn(&cfg)
 			features := cortexFeatures(cfg)
-			assert.Equal(t, tc.expectedFeatures, features)
+
+			// Check API category
+			require.Contains(t, features, "api")
+			assert.Equal(t, tc.queryStatsExpected, features["api"]["query_stats"])
+			assert.True(t, features["api"]["label_values_match"])
+
+			// Check PromQL category
+			require.Contains(t, features, "promql")
+			assert.Equal(t, tc.queryStatsExpected, features["promql"]["per_step_stats"])
+			assert.True(t, features["promql"]["subqueries"])
+
+			// Check PromQL Operators
+			require.Contains(t, features, "promql_operators")
+			assert.True(t, features["promql_operators"]["+"])
+			assert.False(t, features["promql_operators"]["limitk"])
+
+			// Check PromQL Functions
+			require.Contains(t, features, "promql_functions")
+			assert.True(t, features["promql_functions"]["abs"])
+			assert.Equal(t, tc.experimentalExpected, features["promql_functions"]["info"])
 		})
 	}
 }
+