feat: Support list expansions

docs/customresourcestate-metrics.md

@@ -531,6 +531,32 @@ Examples:
 
 # For generally matching against a field in an object schema, use the following syntax:
 [metadata, "name=foo"] # if v, ok := metadata[name]; ok && v == "foo" { return v; } else { /* ignore */ }
+
+# expand a list
+[spec, order, "*", value] # syntax
+# for the object snippet below
+...
+status:
+  namespaces:
+  - namespace: "foo"
+    status:
+      available:
+        resourceA: '10'
+        resourceB: '20'
+      pending:
+        resourceA: '0'
+        resourceB: '6'
+...
+# resolves to: [status, namespaces, <range len(namespaces)>, status] (a multi-dimensional array)
+path: [status, namespaces, "*", status]
+labelsFromPath:
+  # this can be combined with the wildcard prefixes feature introduced in #2052
+  "available_*": [available]
+  "lorem_*": [pending]
+# this can be combined with dynamic valueFrom expressions introduced in #2068
+valueFrom: [lorem_resourceB] # or [available_resourceB]
+# outputs:
+...{...,available_resourceA="10",available_resourceB="20",lorem_resourceA="0",lorem_resourceB="6"...} 6
 ```
 
 ### Wildcard matching of version and kind fields

pkg/customresourcestate/registry_factory.go

@@ -128,12 +128,22 @@ type compiledCommon struct {
 	t             metric.Type
 }
 
+func (c *compiledCommon) SetPath(p valuePath) {
+	c.path = p
+}
+
 func (c compiledCommon) Path() valuePath {
 	return c.path
 }
+
+func (c *compiledCommon) SetLabelFromPath(parr map[string]valuePath) {
+	c.labelFromPath = parr
+}
+
 func (c compiledCommon) LabelFromPath() map[string]valuePath {
 	return c.labelFromPath
 }
+
 func (c compiledCommon) Type() metric.Type {
 	return c.t
 }
@@ -146,7 +156,9 @@ type eachValue struct {
 type compiledMetric interface {
 	Values(v interface{}) (result []eachValue, err []error)
 	Path() valuePath
+	SetPath(valuePath)
 	LabelFromPath() map[string]valuePath
+	SetLabelFromPath(map[string]valuePath)
 	Type() metric.Type
 }
 
@@ -216,6 +228,44 @@ type compiledGauge struct {
 	labelFromKey string
 }
 
+func underscoresToIndices(extractedValueFrom string, it interface{}) interface{} {
+	// `it` is the search space.
+	m, isResolvableMap := it.(map[string]interface{})
+	arr, isResolvableArr := it.([]interface{})
+	if !isResolvableMap && !isResolvableArr {
+		return nil
+	}
+	// `extractedValueFrom` is the search term.
+	// Split `extractedValueFrom` by underscores.
+	terms := strings.Split(extractedValueFrom, "_")
+	resolvedTerm := interface{}(terms[0])
+	for _, term := range terms[1:] {
+		if isResolvableMap {
+			t, ok := m[term]
+			if !ok {
+				return resolvedTerm
+			}
+			resolvedTerm = t
+			if _, isResolvableMap = t.(map[string]interface{}); isResolvableMap {
+				m = t.(map[string]interface{})
+			}
+		} else if isResolvableArr {
+			for _, el := range arr {
+				t, ok := el.(map[string]interface{})
+				if !ok {
+					continue
+				}
+				if v, ok := t[term]; ok {
+					resolvedTerm = v
+					m = t
+					break
+				}
+			}
+		}
+	}
+	return resolvedTerm
+}
+
 func (c *compiledGauge) Values(v interface{}) (result []eachValue, errs []error) {
 	onError := func(err error) {
 		errs = append(errs, fmt.Errorf("%s: %v", c.Path(), err))
@@ -237,9 +287,41 @@ func (c *compiledGauge) Values(v interface{}) (result []eachValue, errs []error)
 				sValueFrom[0] == '[' && sValueFrom[len(sValueFrom)-1] == ']' &&
 				// "[...]" and not "[]".
 				len(sValueFrom) > 2 {
+				// remove the brackets
 				extractedValueFrom := sValueFrom[1 : len(sValueFrom)-1]
-				if key == extractedValueFrom {
-					gotFloat, err := toFloat64(it, c.NilIsZero)
+				// search space to resolve the dynamic valueFrom from the wildcard labels
+				dynamicValueFromScope := c.compiledCommon.labelFromPath
+				lastUnderscoreIndex := strings.LastIndex(extractedValueFrom, "_")
+				if lastUnderscoreIndex != -1 {
+					// For:
+					// labelsFromPath:
+					//  "foo_*": ["spec", "fooObj"]
+					unresolvedKey := extractedValueFrom[:lastUnderscoreIndex] + "_*"
+					dynamicPaths, ok := dynamicValueFromScope[unresolvedKey]
+					if ok {
+						var resolvedKeyArr []string
+						for _, dynamicPath := range dynamicPaths {
+							resolvedKeyArr = append(resolvedKeyArr, dynamicPath.part)
+						}
+						// resolvedKey will map to unresolved key "foo_*"'s corresponding valid path string, i.e., "spec_fooObj_*".
+						resolvedKey := strings.Join(resolvedKeyArr, "_")
+						extractedValueFrom = resolvedKey + extractedValueFrom[lastUnderscoreIndex:]
+					}
+				}
+				if strings.HasPrefix(extractedValueFrom, key) {
+					var gotFloat float64
+					var err error
+					if strings.Contains(extractedValueFrom, "_") {
+						resolvedExtractedValueFrom := underscoresToIndices(extractedValueFrom, it)
+						if _, didResolveFullPath := resolvedExtractedValueFrom.(string); didResolveFullPath {
+							gotFloat, err = toFloat64(resolvedExtractedValueFrom, c.NilIsZero)
+						}
+						if _, isFloat := resolvedExtractedValueFrom.(float64); isFloat {
+							gotFloat = resolvedExtractedValueFrom.(float64)
+						}
+					} else {
+						gotFloat, err = toFloat64(it, c.NilIsZero)
+					}
 					if err != nil {
 						onError(fmt.Errorf("[%s]: %w", key, err))
 						continue
@@ -554,11 +636,35 @@ type pathOp struct {
 type valuePath []pathOp
 
 func (p valuePath) Get(obj interface{}) interface{} {
+	handleNil := func(object interface{}, part string) interface{} {
+		switch tobj := object.(type) {
+		case map[string]interface{}:
+			return tobj[part]
+		case []interface{}:
+			if part == "*" {
+				return tobj
+			}
+			idx, err := strconv.Atoi(part)
+			if err != nil {
+				return nil
+			}
+			if idx < 0 || idx >= len(tobj) {
+				return nil
+			}
+			return tobj[idx]
+		default:
+			return nil
+		}
+	}
 	for _, op := range p {
 		if obj == nil {
 			return nil
 		}
-		obj = op.op(obj)
+		if op.op == nil {
+			obj = handleNil(obj, op.part)
+		} else {
+			obj = op.op(obj)
+		}
 	}
 	return obj
 }
@@ -674,14 +780,85 @@ func famGen(f compiledFamily) generator.FamilyGenerator {
 	}
 }
 
+func findWildcard(path valuePath, i *int) bool {
+	for ; *i < len(path); *i++ {
+		if path[*i].part == "*" {
+			return true
+		}
+	}
+	return false
+}
+
+func resolveWildcard(path valuePath, object map[string]interface{}) []valuePath {
+	if path == nil {
+		return nil
+	}
+	checkpoint := object
+	var expandedPaths []valuePath
+	var list []interface{}
+	var l int
+	for i, j := 0, 0; findWildcard(path, &i); /* i is at "*" now */ {
+		for ; j < i; j++ {
+			maybeCheckpoint, ok := checkpoint[path[j].part]
+			if !ok {
+				// path[j] is not in the object, so we can't expand the wildcard
+				return []valuePath{path}
+			}
+			// store (persist) last checkpoint
+			if c, ok := maybeCheckpoint.([]interface{}); ok {
+				list = c
+				break
+			}
+			checkpoint = maybeCheckpoint.(map[string]interface{})
+		}
+		if j > i {
+			break
+		}
+		// i is at "*", j is at the last part before "*", checkpoint is at the value of the last part before "*"
+		l = len(list) // number of elements in the list
+		pathCopyStart := make(valuePath, i)
+		copy(pathCopyStart, path[:i])
+		pathCopyWildcard := make(valuePath, len(path)-i-1)
+		copy(pathCopyWildcard, path[i+1:])
+		for k := 0; k < l; k++ {
+			pathCopyStart = append(pathCopyStart, pathOp{part: strconv.Itoa(k)})
+			pathCopyStart = append(pathCopyStart, pathCopyWildcard...)
+			expandedPaths = append(expandedPaths, pathCopyStart)
+		}
+		j++ // skip "*"
+	}
+	return expandedPaths[:l]
+}
+
 // generate generates the metrics for a custom resource.
 func generate(u *unstructured.Unstructured, f compiledFamily, errLog klog.Verbose) *metric.Family {
 	klog.V(10).InfoS("Checked", "compiledFamilyName", f.Name, "unstructuredName", u.GetName())
 	var metrics []*metric.Metric
 	baseLabels := f.BaseLabels(u.Object)
+	if f.Each.Path() != nil {
+		fPaths := resolveWildcard(f.Each.Path(), u.Object)
+		for _, fPath := range fPaths {
+			f.Each.SetPath(fPath)
+		}
+	}
+
+	if f.Each.LabelFromPath() != nil {
+		labelsFromPath := make(map[string]valuePath)
+		flfp := f.Each.LabelFromPath()
+		for k, flfpPath := range flfp {
+			fLPaths := resolveWildcard(flfpPath, u.Object)
+			for i, fPath := range fLPaths {
+				genLabel := k + strconv.Itoa(i)
+				labelsFromPath[genLabel] = fPath
+			}
+		}
+		if len(labelsFromPath) > 0 {
+			f.Each.SetLabelFromPath(labelsFromPath)
+		}
+	}
 
-	values, errors := scrapeValuesFor(f.Each, u.Object)
-	for _, err := range errors {
+	values, errorSet := scrapeValuesFor(f.Each, u.Object)
+	for _, err := range errorSet {
 		errLog.ErrorS(err, f.Name)
 	}