implement autocomplete (#3764)

Signed-off-by: Alex Meijer <ameijer@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

pkg/allocation/autocompletequeryservice.go

@@ -0,0 +1,182 @@
+package allocation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/opencost/opencost/core/pkg/filter"
+	"github.com/opencost/opencost/core/pkg/opencost"
+)
+
+// ErrAutocompleteBadRequest indicates a client error in an autocomplete request.
+var ErrAutocompleteBadRequest = errors.New("autocomplete bad request")
+
+// IsAutocompleteBadRequest reports whether err is a client validation error.
+func IsAutocompleteBadRequest(err error) bool {
+	return errors.Is(err, ErrAutocompleteBadRequest)
+}
+
+const DefaultAutocompleteResultLimit = 100
+const MaxAutocompleteResultLimit = 1000
+
+type AllocationAutocompleteRequest struct {
+	Search      string
+	Field       string
+	Limit       int
+	Window      opencost.Window
+	Filter      filter.Filter
+	LabelConfig *opencost.LabelConfig
+}
+
+type AllocationAutocompleteResponse struct {
+	Data []string `json:"data"`
+}
+
+type AutocompleteQueryService interface {
+	QueryAllocationAutocomplete(AllocationAutocompleteRequest, context.Context) (*AllocationAutocompleteResponse, error)
+}
+
+func QueryAllocationAutocompleteFromSetRange(asr *opencost.AllocationSetRange, req AllocationAutocompleteRequest) (*AllocationAutocompleteResponse, error) {
+	field, err := validateAutocompleteField(req.Field)
+	if err != nil {
+		return nil, fmt.Errorf("%w: invalid field: %w", ErrAutocompleteBadRequest, err)
+	}
+
+	limit := req.Limit
+	if limit <= 0 {
+		limit = DefaultAutocompleteResultLimit
+	}
+	if limit > MaxAutocompleteResultLimit {
+		return nil, fmt.Errorf("%w: exceeded maximum autocomplete result limit of %d", ErrAutocompleteBadRequest, MaxAutocompleteResultLimit)
+	}
+
+	var matcher opencost.AllocationMatcher
+	if req.Filter != nil {
+		compiler := opencost.NewAllocationMatchCompiler(req.LabelConfig)
+		matcher, err = compiler.Compile(req.Filter)
+		if err != nil {
+			return nil, fmt.Errorf("%w: failed to compile filter: %w", ErrAutocompleteBadRequest, err)
+		}
+	}
+
+	search := strings.ToLower(req.Search)
+	results := map[string]struct{}{}
+	for _, as := range asr.Allocations {
+		if as == nil {
+			continue
+		}
+		for _, alloc := range as.Allocations {
+			if alloc == nil || alloc.Properties == nil {
+				continue
+			}
+			if matcher != nil && !matcher.Matches(alloc) {
+				continue
+			}
+
+			values := allocationAutocompleteValues(alloc.Properties, field)
+			for _, value := range values {
+				if value == "" {
+					continue
+				}
+				if search != "" && !strings.Contains(strings.ToLower(value), search) {
+					continue
+				}
+				results[value] = struct{}{}
+			}
+		}
+	}
+
+	return &AllocationAutocompleteResponse{Data: uniqueSortedLimited(results, limit)}, nil
+}
+
+func validateAutocompleteField(field string) (string, error) {
+	if field == "" {
+		return "", fmt.Errorf("field is required")
+	}
+
+	f := strings.ToLower(field)
+	switch f {
+	case "cluster", "namespace", "node", "controllerkind", "controllername", "pod", "container", "label", "namespacelabel":
+		return f, nil
+	}
+
+	if strings.HasPrefix(f, "label:") {
+		_, labelKey, _ := strings.Cut(f, ":")
+		return "label:" + labelKey, nil
+	}
+	if strings.HasPrefix(f, "namespacelabel:") {
+		_, labelKey, _ := strings.Cut(f, ":")
+		return "namespacelabel:" + labelKey, nil
+	}
+
+	return "", fmt.Errorf("unrecognized field: %s", field)
+}
+
+func allocationAutocompleteValues(props *opencost.AllocationProperties, field string) []string {
+	switch {
+	case field == "cluster":
+		return []string{props.Cluster}
+	case field == "namespace":
+		return []string{props.Namespace}
+	case field == "node":
+		return []string{props.Node}
+	case field == "controllerkind":
+		return []string{props.ControllerKind}
+	case field == "controllername":
+		return []string{props.Controller}
+	case field == "pod":
+		return []string{props.Pod}
+	case field == "container":
+		return []string{props.Container}
+	case field == "label":
+		return mapKeys(props.Labels)
+	case strings.HasPrefix(field, "label:"):
+		label := strings.TrimPrefix(field, "label:")
+		if v, ok := mapValueFold(props.Labels, label); ok {
+			return []string{v}
+		}
+	case field == "namespacelabel":
+		return mapKeys(props.NamespaceLabels)
+	case strings.HasPrefix(field, "namespacelabel:"):
+		label := strings.TrimPrefix(field, "namespacelabel:")
+		if v, ok := mapValueFold(props.NamespaceLabels, label); ok {
+			return []string{v}
+		}
+	}
+	return nil
+}
+
+func mapKeys(values map[string]string) []string {
+	result := make([]string, 0, len(values))
+	for k := range values {
+		result = append(result, k)
+	}
+	return result
+}
+
+func mapValueFold(values map[string]string, key string) (string, bool) {
+	if v, ok := values[key]; ok {
+		return v, true
+	}
+	for k, v := range values {
+		if strings.EqualFold(k, key) {
+			return v, true
+		}
+	}
+	return "", false
+}
+
+func uniqueSortedLimited(values map[string]struct{}, limit int) []string {
+	out := make([]string, 0, len(values))
+	for v := range values {
+		out = append(out, v)
+	}
+	sort.Strings(out)
+	if len(out) > limit {
+		return out[:limit]
+	}
+	return out
+}

pkg/allocation/autocompletequeryservice_test.go

@@ -0,0 +1,90 @@
+package allocation
+
+import (
+	"testing"
+	"time"
+
+	"github.com/opencost/opencost/core/pkg/opencost"
+)
+
+func TestQueryAllocationAutocompleteFromSetRange(t *testing.T) {
+	start := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
+	as := opencost.NewAllocationSet(start, start.Add(24*time.Hour))
+	as.Set(opencost.NewMockUnitAllocation("a1", start, 24*time.Hour, &opencost.AllocationProperties{
+		Cluster:         "cluster-a",
+		Namespace:       "ns-a",
+		Pod:             "pod-a",
+		Container:       "container-a",
+		ControllerKind:  "deployment",
+		Controller:      "deploy-a",
+		Node:            "node-a",
+		Labels:          map[string]string{"Team": "platform", "app": "api"},
+		NamespaceLabels: map[string]string{"owner": "sre"},
+	}))
+	as.Set(opencost.NewMockUnitAllocation("a2", start, 24*time.Hour, &opencost.AllocationProperties{
+		Cluster:         "cluster-b",
+		Namespace:       "ns-b",
+		Pod:             "pod-b",
+		Container:       "container-b",
+		ControllerKind:  "statefulset",
+		Controller:      "db-a",
+		Node:            "node-b",
+		Labels:          map[string]string{"Team": "data", "app": "db"},
+		NamespaceLabels: map[string]string{"owner": "db"},
+	}))
+
+	asr := opencost.NewAllocationSetRange(as)
+
+	resp, err := QueryAllocationAutocompleteFromSetRange(asr, AllocationAutocompleteRequest{
+		Field: "label",
+		Limit: 10,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(resp.Data) != 2 || resp.Data[0] != "Team" || resp.Data[1] != "app" {
+		t.Fatalf("unexpected label autocomplete response: %+v", resp.Data)
+	}
+
+	valueResp, err := QueryAllocationAutocompleteFromSetRange(asr, AllocationAutocompleteRequest{
+		Field:  "label:team",
+		Search: "plat",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(valueResp.Data) != 1 || valueResp.Data[0] != "platform" {
+		t.Fatalf("unexpected label value autocomplete response: %+v", valueResp.Data)
+	}
+
+	mixedCaseResp, err := QueryAllocationAutocompleteFromSetRange(asr, AllocationAutocompleteRequest{
+		Field: "label:Team",
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mixedCaseResp.Data) != 2 || mixedCaseResp.Data[0] != "data" || mixedCaseResp.Data[1] != "platform" {
+		t.Fatalf("expected label:team to match Team label values, got %+v", mixedCaseResp.Data)
+	}
+
+	_, err = QueryAllocationAutocompleteFromSetRange(asr, AllocationAutocompleteRequest{
+		Field: "account",
+	})
+	if err == nil {
+		t.Fatal("expected error for unsupported account field")
+	}
+	if !IsAutocompleteBadRequest(err) {
+		t.Fatalf("expected bad request error, got: %v", err)
+	}
+
+	_, err = QueryAllocationAutocompleteFromSetRange(asr, AllocationAutocompleteRequest{
+		Field: "namespace",
+		Limit: MaxAutocompleteResultLimit + 1,
+	})
+	if err == nil {
+		t.Fatal("expected error for excessive limit")
+	}
+	if !IsAutocompleteBadRequest(err) {
+		t.Fatalf("expected bad request error, got: %v", err)
+	}
+}

pkg/asset/autocompletequeryservice.go

@@ -0,0 +1,176 @@
+package asset
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/opencost/opencost/core/pkg/filter"
+	"github.com/opencost/opencost/core/pkg/opencost"
+)
+
+// ErrAutocompleteBadRequest indicates a client error in an autocomplete request.
+var ErrAutocompleteBadRequest = errors.New("autocomplete bad request")
+
+// IsAutocompleteBadRequest reports whether err is a client validation error.
+func IsAutocompleteBadRequest(err error) bool {
+	return errors.Is(err, ErrAutocompleteBadRequest)
+}
+
+const DefaultAutocompleteResultLimit = 100
+const MaxAutocompleteResultLimit = 1000
+
+type AssetAutocompleteRequest struct {
+	TenantID string
+	Search   string
+	Field    string
+	Limit    int
+	Window   opencost.Window
+	Filter   filter.Filter
+}
+
+type AssetAutocompleteResponse struct {
+	Data []string `json:"data"`
+}
+
+type AutocompleteQueryService interface {
+	QueryAssetAutocomplete(AssetAutocompleteRequest, context.Context) (*AssetAutocompleteResponse, error)
+}
+
+func QueryAssetAutocompleteFromSet(assetSet *opencost.AssetSet, req AssetAutocompleteRequest) (*AssetAutocompleteResponse, error) {
+	if err := validateAssetAutocompleteWindow(req.Window); err != nil {
+		return nil, err
+	}
+	if req.TenantID == "" {
+		return nil, fmt.Errorf("%w: tenant ID is required", ErrAutocompleteBadRequest)
+	}
+
+	field, err := validateAutocompleteField(req.Field)
+	if err != nil {
+		return nil, fmt.Errorf("%w: invalid field: %w", ErrAutocompleteBadRequest, err)
+	}
+
+	limit := req.Limit
+	if limit <= 0 {
+		limit = DefaultAutocompleteResultLimit
+	}
+	if limit > MaxAutocompleteResultLimit {
+		return nil, fmt.Errorf("%w: exceeded maximum autocomplete result limit of %d", ErrAutocompleteBadRequest, MaxAutocompleteResultLimit)
+	}
+
+	var matcher opencost.AssetMatcher
+	if req.Filter != nil {
+		compiler := opencost.NewAssetMatchCompiler()
+		matcher, err = compiler.Compile(req.Filter)
+		if err != nil {
+			return nil, fmt.Errorf("%w: failed to compile filter: %w", ErrAutocompleteBadRequest, err)
+		}
+	}
+
+	search := strings.ToLower(req.Search)
+	results := map[string]struct{}{}
+	for _, a := range assetSet.Assets {
+		if a == nil {
+			continue
+		}
+		if matcher != nil && !matcher.Matches(a) {
+			continue
+		}
+
+		values := assetAutocompleteValues(a, field)
+		for _, value := range values {
+			if value == "" {
+				continue
+			}
+			if search != "" && !strings.Contains(strings.ToLower(value), search) {
+				continue
+			}
+			results[value] = struct{}{}
+		}
+	}
+
+	data := make([]string, 0, len(results))
+	for value := range results {
+		data = append(data, value)
+	}
+	sort.Strings(data)
+	if len(data) > limit {
+		data = data[:limit]
+	}
+	return &AssetAutocompleteResponse{Data: data}, nil
+}
+
+func validateAutocompleteField(field string) (string, error) {
+	f := strings.ToLower(field)
+	switch f {
+	case "account", "cluster", "name", "provider", "providerid", "type", "category":
+		return f, nil
+	}
+	if f == "label" {
+		return f, nil
+	}
+	if strings.HasPrefix(f, "label:") {
+		_, labelKey, _ := strings.Cut(f, ":")
+		return "label:" + labelKey, nil
+	}
+	return "", fmt.Errorf("unrecognized field: %s", field)
+}
+
+func validateAssetAutocompleteWindow(window opencost.Window) error {
+	if window.IsOpen() {
+		return fmt.Errorf("%w: invalid window: %s", ErrAutocompleteBadRequest, window.String())
+	}
+	if window.Start() == nil || window.End() == nil {
+		return fmt.Errorf("%w: invalid window: missing start or end", ErrAutocompleteBadRequest)
+	}
+	return nil
+}
+
+func assetAutocompleteValues(asset opencost.Asset, field string) []string {
+	props := asset.GetProperties()
+	if props == nil {
+		return nil
+	}
+	switch {
+	case field == "account":
+		return []string{props.Account}
+	case field == "cluster":
+		return []string{props.Cluster}
+	case field == "name":
+		return []string{props.Name}
+	case field == "provider":
+		return []string{props.Provider}
+	case field == "providerid":
+		return []string{props.ProviderID}
+	case field == "type":
+		return []string{asset.Type().String()}
+	case field == "category":
+		return []string{props.Category}
+	case field == "label":
+		keys := make([]string, 0, len(asset.GetLabels()))
+		for key := range asset.GetLabels() {
+			keys = append(keys, key)
+		}
+		return keys
+	case strings.HasPrefix(field, "label:"):
+		labelName := strings.TrimPrefix(field, "label:")
+		if value, ok := mapValueFold(asset.GetLabels(), labelName); ok {
+			return []string{value}
+		}
+	}
+	return nil
+}
+
+func mapValueFold(values map[string]string, key string) (string, bool) {
+	if v, ok := values[key]; ok {
+		return v, true
+	}
+	for k, v := range values {
+		if strings.EqualFold(k, key) {
+			return v, true
+		}
+	}
+	return "", false
+}

pkg/asset/autocompletequeryservice_test.go

@@ -0,0 +1,86 @@
+package asset
+
+import (
+	"testing"
+	"time"
+
+	"github.com/opencost/opencost/core/pkg/opencost"
+)
+
+func TestQueryAssetAutocompleteFromSet(t *testing.T) {
+	start := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
+	end := start.Add(24 * time.Hour)
+	window := opencost.NewClosedWindow(start, end)
+
+	nodeA := opencost.NewNode("node-a", "cluster-a", "provider-a", start, end, window)
+	nodeA.SetLabels(map[string]string{"team": "platform", "app": "api"})
+	nodeA.GetProperties().Account = "acct-a"
+	nodeA.GetProperties().Category = opencost.ComputeCategory
+
+	nodeB := opencost.NewNode("node-b", "cluster-b", "provider-b", start, end, window)
+	nodeB.SetLabels(map[string]string{"team": "data", "app": "db"})
+	nodeB.GetProperties().Account = "acct-b"
+	nodeB.GetProperties().Category = opencost.ComputeCategory
+
+	assetSet := opencost.NewAssetSet(start, end, nodeA, nodeB)
+
+	resp, err := QueryAssetAutocompleteFromSet(assetSet, AssetAutocompleteRequest{
+		TenantID: "opencost",
+		Field:    "cluster",
+		Window:   window,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(resp.Data) != 2 || resp.Data[0] != "cluster-a" || resp.Data[1] != "cluster-b" {
+		t.Fatalf("unexpected cluster autocomplete response: %+v", resp.Data)
+	}
+
+	labelResp, err := QueryAssetAutocompleteFromSet(assetSet, AssetAutocompleteRequest{
+		TenantID: "opencost",
+		Field:    "label:team",
+		Search:   "plat",
+		Window:   window,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(labelResp.Data) != 1 || labelResp.Data[0] != "platform" {
+		t.Fatalf("unexpected label autocomplete response: %+v", labelResp.Data)
+	}
+
+	_, err = QueryAssetAutocompleteFromSet(assetSet, AssetAutocompleteRequest{
+		Field: "cluster",
+	})
+	if err == nil {
+		t.Fatal("expected error when tenant ID is missing")
+	}
+	if !IsAutocompleteBadRequest(err) {
+		t.Fatalf("expected bad request error, got: %v", err)
+	}
+
+	_, err = QueryAssetAutocompleteFromSet(assetSet, AssetAutocompleteRequest{
+		TenantID: "opencost",
+		Field:    "labels",
+		Window:   window,
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid field prefix")
+	}
+	if !IsAutocompleteBadRequest(err) {
+		t.Fatalf("expected bad request error, got: %v", err)
+	}
+
+	openWindow := opencost.NewWindow(&start, nil)
+	_, err = QueryAssetAutocompleteFromSet(assetSet, AssetAutocompleteRequest{
+		TenantID: "opencost",
+		Field:    "name",
+		Window:   openWindow,
+	})
+	if err == nil {
+		t.Fatal("expected error for open window")
+	}
+	if !IsAutocompleteBadRequest(err) {
+		t.Fatalf("expected bad request error, got: %v", err)
+	}
+}

pkg/cloudcost/autocomplete_test.go

@@ -0,0 +1,79 @@
+package cloudcost
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/opencost/opencost/core/pkg/opencost"
+)
+
+func TestRepositoryQuerier_QueryCloudCostAutocomplete(t *testing.T) {
+	start := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
+	end := start.Add(24 * time.Hour)
+
+	repo := NewMemoryRepository()
+	ccs := DefaultMockCloudCostSet(start, end, "aws", "integration-1")
+	if err := repo.Put(ccs); err != nil {
+		t.Fatalf("failed to seed repository: %v", err)
+	}
+	rq := NewRepositoryQuerier(repo)
+
+	resp, err := rq.QueryCloudCostAutocomplete(context.Background(), CloudCostAutocompleteRequest{
+		Field:  opencost.CloudCostServiceProp,
+		Window: opencost.NewClosedWindow(start, end),
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(resp.Data) != 2 {
+		t.Fatalf("expected 2 service values, got %d: %+v", len(resp.Data), resp.Data)
+	}
+
+	labelResp, err := rq.QueryCloudCostAutocomplete(context.Background(), CloudCostAutocompleteRequest{
+		Field:  "label:label1",
+		Search: "value1",
+		Window: opencost.NewClosedWindow(start, end),
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(labelResp.Data) != 1 || labelResp.Data[0] != "value1" {
+		t.Fatalf("unexpected label autocomplete response: %+v", labelResp.Data)
+	}
+
+	_, err = rq.QueryCloudCostAutocomplete(context.Background(), CloudCostAutocompleteRequest{
+		Field:  opencost.CloudCostServiceProp,
+		Limit:  MaxAutocompleteResultLimit + 1,
+		Window: opencost.NewClosedWindow(start, end),
+	})
+	if err == nil {
+		t.Fatal("expected error for excessive limit")
+	}
+	if !IsAutocompleteBadRequest(err) {
+		t.Fatalf("expected bad request error, got: %v", err)
+	}
+
+	_, err = rq.QueryCloudCostAutocomplete(context.Background(), CloudCostAutocompleteRequest{
+		Field:  "not-a-real-field",
+		Window: opencost.NewClosedWindow(start, end),
+	})
+	if err == nil {
+		t.Fatal("expected error for invalid field")
+	}
+	if !IsAutocompleteBadRequest(err) {
+		t.Fatalf("expected bad request error, got: %v", err)
+	}
+
+	mixedCaseResp, err := rq.QueryCloudCostAutocomplete(context.Background(), CloudCostAutocompleteRequest{
+		Field:  "label:Label1",
+		Search: "value1",
+		Window: opencost.NewClosedWindow(start, end),
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mixedCaseResp.Data) != 1 || mixedCaseResp.Data[0] != "value1" {
+		t.Fatalf("unexpected mixed-case label autocomplete response: %+v", mixedCaseResp.Data)
+	}
+}

pkg/cloudcost/querier.go

@@ -13,6 +13,7 @@ import (
 // Querier allows for querying ranges of CloudCost data
 type Querier interface {
 	Query(context.Context, QueryRequest) (*opencost.CloudCostSetRange, error)
+	QueryCloudCostAutocomplete(context.Context, CloudCostAutocompleteRequest) (*CloudCostAutocompleteResponse, error)
 }
 
 type QueryRequest struct {
@@ -23,6 +24,21 @@ type QueryRequest struct {
 	Filter      filter.Filter
 }
 
+const DefaultAutocompleteResultLimit = 100
+const MaxAutocompleteResultLimit = 1000
+
+type CloudCostAutocompleteRequest struct {
+	Search string
+	Field  string
+	Limit  int
+	Window opencost.Window
+	Filter filter.Filter
+}
+
+type CloudCostAutocompleteResponse struct {
+	Data []string `json:"data"`
+}
+
 // DefaultChartItemsLength the default max number of items for a ViewGraphDataSet
 const DefaultChartItemsLength int = 10
 

pkg/cloudcost/queryservice.go

@@ -1,6 +1,7 @@
 package cloudcost
 
 import (
+	"errors"
 	"fmt"
 	"net/http"
 	"strings"
@@ -68,6 +69,43 @@ func (s *QueryService) GetCloudCostHandler() func(w http.ResponseWriter, r *http
 	}
 }
 
+func (s *QueryService) GetCloudCostAutocompleteHandler() func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+	return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+		tracer := otel.Tracer(tracerName)
+		ctx, span := tracer.Start(r.Context(), "Service.GetCloudCostAutocompleteHandler")
+		defer span.End()
+
+		if s == nil {
+			http.Error(w, "Query Service is nil", http.StatusNotImplemented)
+			return
+		}
+		if s.Querier == nil {
+			http.Error(w, "CloudCost Query Service is nil", http.StatusNotImplemented)
+			return
+		}
+
+		qp := httputil.NewQueryParams(r.URL.Query())
+		request, err := ParseCloudCostAutocompleteRequest(qp)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		resp, err := s.Querier.QueryCloudCostAutocomplete(ctx, *request)
+		if err != nil {
+			if errors.Is(err, ErrAutocompleteBadRequest) {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			http.Error(w, fmt.Sprintf("Internal server error: %s", err), http.StatusInternalServerError)
+			return
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		protocol.WriteData(w, resp)
+	}
+}
+
 func (s *QueryService) GetCloudCostViewGraphHandler() func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 	// Return valid handler func
 	return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {

pkg/cloudcost/queryservice_helper.go

@@ -15,7 +15,7 @@ func ParseCloudCostRequest(qp httputil.QueryParams) (*QueryRequest, error) {
 
 	windowStr := qp.Get("window", "")
 	if windowStr == "" {
-		return nil, fmt.Errorf("missing require window param")
+		return nil, fmt.Errorf("missing required 'window' parameter")
 	}
 
 	window, err := opencost.ParseWindowUTC(windowStr)
@@ -49,7 +49,7 @@ func ParseCloudCostRequest(qp httputil.QueryParams) (*QueryRequest, error) {
 		parser := cloudcost.NewCloudCostFilterParser()
 		filter, err = parser.Parse(filterString)
 		if err != nil {
-			return nil, fmt.Errorf("Parsing 'filter' parameter: %s", err)
+			return nil, fmt.Errorf("invalid 'filter' parameter: %w", err)
 		}
 	}
 
@@ -64,6 +64,43 @@ func ParseCloudCostRequest(qp httputil.QueryParams) (*QueryRequest, error) {
 	return opts, nil
 }
 
+func ParseCloudCostAutocompleteRequest(qp httputil.QueryParams) (*CloudCostAutocompleteRequest, error) {
+	windowStr := qp.Get("window", "")
+	if windowStr == "" {
+		return nil, fmt.Errorf("missing required 'window' parameter")
+	}
+
+	window, err := opencost.ParseWindowUTC(windowStr)
+	if err != nil {
+		return nil, fmt.Errorf("invalid window parameter: %w", err)
+	}
+	if window.IsOpen() {
+		return nil, fmt.Errorf("invalid window parameter: %s", window.String())
+	}
+
+	var parsedFilter filter.Filter
+	filterString := qp.Get("filter", "")
+	if filterString != "" {
+		parser := cloudcost.NewCloudCostFilterParser()
+		parsedFilter, err = parser.Parse(filterString)
+		if err != nil {
+			return nil, fmt.Errorf("invalid 'filter' parameter: %w", err)
+		}
+	}
+
+	req := &CloudCostAutocompleteRequest{
+		Search: qp.Get("search", ""),
+		Field:  qp.Get("field", ""),
+		Limit:  qp.GetInt("limit", 0),
+		Window: window,
+		Filter: parsedFilter,
+	}
+	if req.Field == "" {
+		return nil, fmt.Errorf("missing required 'field' parameter")
+	}
+	return req, nil
+}
+
 func ParseCloudCostViewRequest(qp httputil.QueryParams) (*ViewQueryRequest, error) {
 	qr, err := ParseCloudCostRequest(qp)
 	if err != nil {

pkg/cloudcost/queryservice_helper_test.go

@@ -134,3 +134,82 @@ func TestParseCloudCostRequest(t *testing.T) {
 		})
 	}
 }
+
+func TestParseCloudCostAutocompleteRequest(t *testing.T) {
+	windowStr := "2023-01-01T00:00:00Z,2023-01-02T00:00:00Z"
+	validFilterStr := `service:"AmazonEC2"`
+	parser := cloudcost.NewCloudCostFilterParser()
+	validFilter, _ := parser.Parse(validFilterStr)
+
+	tests := map[string]struct {
+		values  map[string][]string
+		want    *CloudCostAutocompleteRequest
+		wantErr bool
+	}{
+		"missing window": {
+			values:  map[string][]string{"field": {"service"}},
+			wantErr: true,
+		},
+		"missing field": {
+			values:  map[string][]string{"window": {windowStr}},
+			wantErr: true,
+		},
+		"invalid window": {
+			values: map[string][]string{
+				"window": {"invalid"},
+				"field":  {"service"},
+			},
+			wantErr: true,
+		},
+		"open window": {
+			values: map[string][]string{
+				"window": {"2023-01-01T00:00:00Z,"},
+				"field":  {"service"},
+			},
+			wantErr: true,
+		},
+		"invalid filter": {
+			values: map[string][]string{
+				"window": {windowStr},
+				"field":  {"service"},
+				"filter": {"invalid"},
+			},
+			wantErr: true,
+		},
+		"valid request": {
+			values: map[string][]string{
+				"window": {windowStr},
+				"field":  {"service"},
+				"filter": {validFilterStr},
+				"search": {"ec2"},
+				"limit":  {"25"},
+			},
+			want: &CloudCostAutocompleteRequest{
+				Search: "ec2",
+				Field:  "service",
+				Limit:  25,
+				Filter: validFilter,
+			},
+			wantErr: false,
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			qp := httputil.NewQueryParams(tt.values)
+			got, err := ParseCloudCostAutocompleteRequest(qp)
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("ParseCloudCostAutocompleteRequest() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if tt.wantErr {
+				return
+			}
+			if got.Search != tt.want.Search || got.Field != tt.want.Field || got.Limit != tt.want.Limit {
+				t.Fatalf("unexpected request: got=%+v want=%+v", got, tt.want)
+			}
+			if got.Window.IsOpen() {
+				t.Fatal("expected closed window")
+			}
+		})
+	}
+}

pkg/cloudcost/repositoryquerier.go

@@ -2,13 +2,23 @@ package cloudcost
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"sort"
+	"strings"
 
 	"github.com/opencost/opencost/core/pkg/log"
 	"github.com/opencost/opencost/core/pkg/opencost"
 )
 
+// ErrAutocompleteBadRequest indicates a client error in an autocomplete request.
+var ErrAutocompleteBadRequest = errors.New("autocomplete bad request")
+
+// IsAutocompleteBadRequest reports whether err is a client validation error.
+func IsAutocompleteBadRequest(err error) bool {
+	return errors.Is(err, ErrAutocompleteBadRequest)
+}
+
 // RepositoryQuerier is an implementation of Querier and ViewQuerier which pulls directly from a Repository
 type RepositoryQuerier struct {
 	repo Repository
@@ -67,6 +77,129 @@ func (rq *RepositoryQuerier) Query(ctx context.Context, request QueryRequest) (*
 	return ccsr, nil
 }
 
+func (rq *RepositoryQuerier) QueryCloudCostAutocomplete(ctx context.Context, request CloudCostAutocompleteRequest) (*CloudCostAutocompleteResponse, error) {
+	if request.Window.IsOpen() {
+		return nil, fmt.Errorf("%w: invalid window for autocomplete query: %s", ErrAutocompleteBadRequest, request.Window.String())
+	}
+
+	limit := request.Limit
+	if limit <= 0 {
+		limit = DefaultAutocompleteResultLimit
+	}
+	if limit > MaxAutocompleteResultLimit {
+		return nil, fmt.Errorf("%w: exceeded maximum autocomplete result limit of %d", ErrAutocompleteBadRequest, MaxAutocompleteResultLimit)
+	}
+
+	field, err := validateCloudCostAutocompleteField(request.Field)
+	if err != nil {
+		return nil, fmt.Errorf("%w: invalid field: %w", ErrAutocompleteBadRequest, err)
+	}
+
+	ccsr, err := rq.Query(ctx, QueryRequest{
+		Start:      *request.Window.Start(),
+		End:        *request.Window.End(),
+		Accumulate: opencost.AccumulateOptionNone,
+		Filter:     request.Filter,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("QueryCloudCostAutocomplete: query failed: %w", err)
+	}
+
+	search := strings.ToLower(request.Search)
+	results := map[string]struct{}{}
+	for _, ccs := range ccsr.CloudCostSets {
+		for _, cc := range ccs.CloudCosts {
+			if cc == nil || cc.Properties == nil {
+				continue
+			}
+
+			values := cloudCostAutocompleteValues(cc, field)
+			for _, value := range values {
+				if value == "" {
+					continue
+				}
+				if search != "" && !strings.Contains(strings.ToLower(value), search) {
+					continue
+				}
+				results[value] = struct{}{}
+			}
+		}
+	}
+
+	data := make([]string, 0, len(results))
+	for result := range results {
+		data = append(data, result)
+	}
+	sort.Strings(data)
+	if len(data) > limit {
+		data = data[:limit]
+	}
+
+	return &CloudCostAutocompleteResponse{Data: data}, nil
+}
+
+func validateCloudCostAutocompleteField(field string) (string, error) {
+	if field == "" {
+		return "", fmt.Errorf("field is required")
+	}
+
+	f := strings.ToLower(field)
+	if f == "label" {
+		return f, nil
+	}
+	if strings.HasPrefix(f, "label:") {
+		_, labelKey, _ := strings.Cut(f, ":")
+		return "label:" + labelKey, nil
+	}
+
+	property, err := opencost.ParseCloudCostProperty(field)
+	if err != nil {
+		return "", err
+	}
+	return string(property), nil
+}
+
+func cloudCostAutocompleteValues(cc *opencost.CloudCost, field string) []string {
+	if field == "label" {
+		keys := make([]string, 0, len(cc.Properties.Labels))
+		for label := range cc.Properties.Labels {
+			keys = append(keys, label)
+		}
+		return keys
+	}
+	if strings.HasPrefix(field, "label:") {
+		labelName := strings.TrimPrefix(field, "label:")
+		if value, ok := cloudCostLabelValueFold(cc.Properties.Labels, labelName); ok {
+			return []string{value}
+		}
+		return nil
+	}
+
+	property, err := opencost.ParseCloudCostProperty(field)
+	if err != nil {
+		return nil
+	}
+
+	value, err := cc.StringProperty(string(property))
+	if err != nil {
+		return nil
+	}
+
+	return []string{value}
+}
+
+func cloudCostLabelValueFold(labels map[string]string, key string) (string, bool) {
+	if v, ok := labels[key]; ok {
+		return v, true
+	}
+	for k, v := range labels {
+		if strings.EqualFold(k, key) {
+			return v, true
+		}
+	}
+	return "", false
+}
+
 func (rq *RepositoryQuerier) QueryViewGraph(ctx context.Context, request ViewQueryRequest) (ViewGraphData, error) {
 	ccasr, err := rq.Query(ctx, request.QueryRequest)
 	if err != nil {

pkg/costmodel/autocomplete.go

@@ -0,0 +1,122 @@
+package costmodel
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/julienschmidt/httprouter"
+	"github.com/opencost/opencost/core/pkg/filter"
+	allocationfilter "github.com/opencost/opencost/core/pkg/filter/allocation"
+	assetfilter "github.com/opencost/opencost/core/pkg/filter/asset"
+	"github.com/opencost/opencost/core/pkg/opencost"
+	"github.com/opencost/opencost/core/pkg/util/httputil"
+	"github.com/opencost/opencost/pkg/allocation"
+	"github.com/opencost/opencost/pkg/asset"
+	"github.com/opencost/opencost/pkg/env"
+)
+
+func (a *Accesses) ComputeAllocationAutocompleteHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+	w.Header().Set("Content-Type", "application/json")
+	qp := httputil.NewQueryParams(r.URL.Query())
+
+	window, err := opencost.ParseWindowWithOffset(qp.Get("window", ""), env.GetParsedUTCOffset())
+	if err != nil {
+		http.Error(w, fmt.Sprintf("Invalid 'window' parameter: %s", err), http.StatusBadRequest)
+		return
+	}
+
+	var parsedFilter filter.Filter
+	filterString := qp.Get("filter", "")
+	if filterString != "" {
+		parser := allocationfilter.NewAllocationFilterParser()
+		parsedFilter, err = parser.Parse(filterString)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("Invalid 'filter' parameter: %s", err), http.StatusBadRequest)
+			return
+		}
+	}
+
+	resp, err := a.QueryAllocationAutocomplete(allocation.AllocationAutocompleteRequest{
+		Search:      qp.Get("search", ""),
+		Field:       qp.Get("field", ""),
+		Limit:       qp.GetInt("limit", 0),
+		Window:      window,
+		Filter:      parsedFilter,
+		LabelConfig: opencost.NewLabelConfig(),
+	}, filterString, r.Context())
+	if err != nil {
+		status := http.StatusInternalServerError
+		if allocation.IsAutocompleteBadRequest(err) {
+			status = http.StatusBadRequest
+		}
+		http.Error(w, fmt.Sprintf("Error getting allocation autocomplete: %s", err), status)
+		return
+	}
+
+	WriteData(w, resp, nil)
+}
+
+func (a *Accesses) QueryAllocationAutocomplete(req allocation.AllocationAutocompleteRequest, filterString string, ctx context.Context) (*allocation.AllocationAutocompleteResponse, error) {
+	asr, err := a.Model.QueryAllocation(req.Window, req.Window.Duration(), nil, false, false, false, false, false, opencost.AccumulateOptionNone, false, filterString)
+	if err != nil {
+		return nil, fmt.Errorf("error querying allocations: %w", err)
+	}
+	return allocation.QueryAllocationAutocompleteFromSetRange(asr, req)
+}
+
+func (a *Accesses) ComputeAssetsAutocompleteHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+	w.Header().Set("Content-Type", "application/json")
+	qp := httputil.NewQueryParams(r.URL.Query())
+
+	window, err := opencost.ParseWindowWithOffset(qp.Get("window", ""), env.GetParsedUTCOffset())
+	if err != nil {
+		http.Error(w, fmt.Sprintf("Invalid 'window' parameter: %s", err), http.StatusBadRequest)
+		return
+	}
+	if window.IsOpen() || window.Start() == nil || window.End() == nil {
+		http.Error(w, fmt.Sprintf("Invalid 'window' parameter: %s", window.String()), http.StatusBadRequest)
+		return
+	}
+
+	var parsedFilter filter.Filter
+	filterString := qp.Get("filter", "")
+	if filterString != "" {
+		parser := assetfilter.NewAssetFilterParser()
+		parsedFilter, err = parser.Parse(filterString)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("Invalid 'filter' parameter: %s", err), http.StatusBadRequest)
+			return
+		}
+	}
+
+	resp, err := a.QueryAssetAutocomplete(asset.AssetAutocompleteRequest{
+		TenantID: qp.Get("tenantId", "opencost"),
+		Search:   qp.Get("search", ""),
+		Field:    qp.Get("field", ""),
+		Limit:    qp.GetInt("limit", 0),
+		Window:   window,
+		Filter:   parsedFilter,
+	}, r.Context())
+	if err != nil {
+		status := http.StatusInternalServerError
+		if asset.IsAutocompleteBadRequest(err) {
+			status = http.StatusBadRequest
+		}
+		http.Error(w, fmt.Sprintf("Error getting asset autocomplete: %s", err), status)
+		return
+	}
+
+	WriteData(w, resp, nil)
+}
+
+func (a *Accesses) QueryAssetAutocomplete(req asset.AssetAutocompleteRequest, ctx context.Context) (*asset.AssetAutocompleteResponse, error) {
+	if req.Window.IsOpen() || req.Window.Start() == nil || req.Window.End() == nil {
+		return nil, fmt.Errorf("%w: invalid window: %s", asset.ErrAutocompleteBadRequest, req.Window.String())
+	}
+	assetSet, err := a.Model.ComputeAssets(*req.Window.Start(), *req.Window.End())
+	if err != nil {
+		return nil, fmt.Errorf("error computing assets: %w", err)
+	}
+	return asset.QueryAssetAutocompleteFromSet(assetSet, req)
+}

pkg/costmodel/router.go

@@ -556,6 +556,8 @@ func Initialize(router *httprouter.Router, additionalConfigWatchers ...*watcher.
 	router.GET("/costDataModel", a.CostDataModel)
 	router.GET("/allocation/compute", a.ComputeAllocationHandler)
 	router.GET("/allocation/compute/summary", a.ComputeAllocationHandlerSummary)
+	router.GET("/allocation/autocomplete", a.ComputeAllocationAutocompleteHandler)
+	router.GET("/assets/autocomplete", a.ComputeAssetsAutocompleteHandler)
 	router.GET("/allNodePricing", a.GetAllNodePricing)
 	router.POST("/refreshPricing", a.RefreshPricingData)
 	router.GET("/managementPlatform", a.ManagementPlatform)
@@ -617,6 +619,7 @@ func InitializeCloudCost(router *httprouter.Router) *cloudcost.PipelineService {
 	cloudCostQueryService := cloudcost.NewQueryService(repoQuerier, repoQuerier)
 
 	router.GET("/cloudCost", cloudCostQueryService.GetCloudCostHandler())
+	router.GET("/cloudCost/autocomplete", cloudCostQueryService.GetCloudCostAutocompleteHandler())
 	router.GET("/cloudCost/view/graph", cloudCostQueryService.GetCloudCostViewGraphHandler())
 	router.GET("/cloudCost/view/totals", cloudCostQueryService.GetCloudCostViewTotalsHandler())
 	router.GET("/cloudCost/view/table", cloudCostQueryService.GetCloudCostViewTableHandler(nil))

pkg/mcp/server_test.go

@@ -544,6 +544,10 @@ func (dq *dummyQuerier) Query(_ context.Context, req cloudcost.QueryRequest) (*o
 	return ccsr, nil
 }
 
+func (dq *dummyQuerier) QueryCloudCostAutocomplete(_ context.Context, _ cloudcost.CloudCostAutocompleteRequest) (*cloudcost.CloudCostAutocompleteResponse, error) {
+	return &cloudcost.CloudCostAutocompleteResponse{Data: []string{}}, nil
+}
+
 func TestBuildCloudCostQueryRequest_AccumulateParsing(t *testing.T) {
 	s := &MCPServer{}
 	req := cloudcost.QueryRequest{}
@@ -1481,6 +1485,16 @@ func (caq *contextAwareQuerier) Query(ctx context.Context, req cloudcost.QueryRe
 	}
 }
 
+func (caq *contextAwareQuerier) QueryCloudCostAutocomplete(ctx context.Context, _ cloudcost.CloudCostAutocompleteRequest) (*cloudcost.CloudCostAutocompleteResponse, error) {
+	select {
+	case <-ctx.Done():
+		caq.contextWasCancelled = true
+		return nil, ctx.Err()
+	default:
+		return &cloudcost.CloudCostAutocompleteResponse{Data: []string{}}, nil
+	}
+}
+
 func TestQueryCloudCosts_ContextCancellation(t *testing.T) {
 	// Create a context that is already cancelled
 	ctx, cancel := context.WithCancel(context.Background())