#52217 - VAI: Pod Restart Shows Stale Value (#1011)

* initial implementation

* added tests

* moved to use a more generic approach

* added conditional for multivalue converter

* updated tests

* improved unit tests

* made no index being default subindex 0

* added tests

* fixed formatter

* better naming

* moved to separate fields

* added tests for timestamp

* fixing unit tests

* better error log + matchesGVK as common

* updated to have compositeInt

* addressing more comments

* addressing more comments

* removed watchers var

* changed formatter to be more efficient

* introducing indexed fields

* removed composite int and fixed tests

* changed to flat field definition + maps for optimization

* addressed comments from tomleb

* simplified the logic

* addressed comments from @tomleb

* reduced complexity

* removed integer

* removed COMPOSITE_INT references

* changed podrestarts test to use struct

* called getTypeGuidance first

* removed obvious comments

* removed more unused comments

* fixed formatting

* fixed formatting again

* fixed tests and formatting

* goimports

* removed unused param by @tomleb

* fixed format

Author: gehrkefc

pkg/resources/common/duration_test.go

@@ -17,7 +17,7 @@ func TestParseHumanReadableDuration(t *testing.T) {
 		{
 			name:     "years + days",
 			input:    "2y10d",
-			expected: (2*365+10)*24*time.Hour,
+			expected: (2*365 + 10) * 24 * time.Hour,
 		},
 		{
 			name:     "years + days + hours + mins + secs",

pkg/resources/common/formatter.go

@@ -10,6 +10,7 @@ import (
 	"github.com/rancher/apiserver/pkg/types"
 	"github.com/rancher/steve/pkg/accesscontrol"
 	"github.com/rancher/steve/pkg/attributes"
+	"github.com/rancher/steve/pkg/resources/common/formatters"
 	"github.com/rancher/steve/pkg/resources/virtual/common"
 	"github.com/sirupsen/logrus"
 
@@ -180,6 +181,7 @@ func formatter(summarycache common.SummaryCache, asl accesscontrol.AccessSetLook
 
 			if options.InSQLMode {
 				isCRD := attributes.IsCRD(resource.Schema)
+				convertMetadataMultiValueFields(request, gvk, unstr)
 				convertMetadataTimestampFields(request, gvk, unstr, isCRD)
 			}
 		}
@@ -237,71 +239,126 @@ func excludeFields(request *types.APIRequest, unstr *unstructured.Unstructured)
 	}
 }
 
+// convertMetadataMultiValueFields converts multi-value JSON arrays back to display strings
+func convertMetadataMultiValueFields(request *types.APIRequest, gvk schema2.GroupVersionKind, unstr *unstructured.Unstructured) {
+	if request.Schema == nil {
+		return
+	}
+
+	if gvk != PodGVK {
+		return
+	}
+
+	curValue, got, err := unstructured.NestedSlice(unstr.Object, "metadata", "fields")
+	if err != nil || !got {
+		return
+	}
+
+	changedFields := false
+	cols := GetColumnDefinitions(request.Schema)
+	for _, col := range cols {
+		index := GetIndexValueFromString(col.Field)
+		if index == -1 {
+			continue
+		}
+
+		if index >= len(curValue) {
+			continue
+		}
+
+		arr, ok := curValue[index].([]interface{})
+		if !ok || len(arr) < 2 {
+			continue
+		}
+
+		if col.Name == "Restarts" && gvk == PodGVK {
+			curValue[index] = formatters.FormatRestarts(arr)
+			changedFields = true
+			break
+		}
+
+		// Future: Add other multi-value field formatters here
+	}
+
+	if changedFields {
+		if err := unstructured.SetNestedSlice(unstr.Object, curValue, "metadata", "fields"); err != nil {
+			logrus.Errorf("failed to set multi-value display value: %s", err.Error())
+		}
+	}
+}
+
 // convertMetadataTimestampFields updates metadata timestamp fields to ensure they remain fresh and human-readable when sent back
 // to the client. Internally, fields are stored as Unix timestamps; on each request, we calculate the elapsed time since
 // those timestamps by subtracting them from time.Now(), then format the resulting duration into a human-friendly string.
 // This prevents cached durations (e.g. “2d” - 2 days) from becoming stale over time.
 func convertMetadataTimestampFields(request *types.APIRequest, gvk schema2.GroupVersionKind, unstr *unstructured.Unstructured, isCRD bool) {
-	if request.Schema != nil {
-		cols := GetColumnDefinitions(request.Schema)
-		for _, col := range cols {
-			gvkDateFields, gvkFound := DateFieldsByGVK[gvk]
-
-			hasCRDDateField := isCRD && col.Type == "date"
-			hasGVKDateFieldMapping := gvkFound && slices.Contains(gvkDateFields, col.Name)
-			if hasCRDDateField || hasGVKDateFieldMapping {
-				index := GetIndexValueFromString(col.Field)
-				if index == -1 {
-					logrus.Errorf("field index not found at column.Field struct variable: %s", col.Field)
-					return
-				}
+	if request.Schema == nil {
+		return
+	}
 
-				curValue, got, err := unstructured.NestedSlice(unstr.Object, "metadata", "fields")
-				if err != nil {
-					logrus.Warnf("failed to get metadata.fields slice from unstr.Object: %s", err.Error())
-					return
-				}
+	gvkDateFields, gvkFound := DateFieldsByGVK[gvk]
+	if !isCRD && !gvkFound {
+		return
+	}
 
-				if !got {
-					logrus.Warnf("couldn't find metadata.fields at unstr.Object")
-					return
-				}
+	curValue, got, err := unstructured.NestedSlice(unstr.Object, "metadata", "fields")
+	if err != nil || !got {
+		return
+	}
 
-				timeValue, ok := curValue[index].(string)
-				if !ok {
-					logrus.Warnf("time field isn't a string")
-					return
-				}
+	changedFields := false
+	cols := GetColumnDefinitions(request.Schema)
+	for _, col := range cols {
+		index := GetIndexValueFromString(col.Field)
+		if index == -1 {
+			continue
+		}
 
-				if _, err := time.Parse(time.RFC3339, timeValue); err == nil {
-					// it's already a timestamp, so we don't need to do anything
-					return
-				}
+		if index >= len(curValue) {
+			continue
+		}
 
-				dur, ok := isDuration(timeValue)
-				if !ok {
-					millis, err := strconv.ParseInt(timeValue, 10, 64)
-					if err != nil {
-						logrus.Warnf("convert timestamp value: %s failed with error: %s", timeValue, err.Error())
-						return
-					}
+		hasCRDDateField := isCRD && col.Type == "date"
+		hasGVKDateFieldMapping := gvkFound && slices.Contains(gvkDateFields, col.Name)
+		if !hasCRDDateField && !hasGVKDateFieldMapping {
+			continue
+		}
 
-					timestamp := time.Unix(0, millis*int64(time.Millisecond))
-					dur = time.Since(timestamp)
-				}
+		timeValue, ok := curValue[index].(string)
+		if !ok {
+			logrus.Warnf("time field isn't a string")
+			continue
+		}
 
-				humanDuration := duration.HumanDuration(dur)
-				if humanDuration == "<invalid>" {
-					logrus.Warnf("couldn't convert value %d into human duration for column %s", int64(dur), col.Name)
-					return
-				}
+		if _, err := time.Parse(time.RFC3339, timeValue); err == nil {
+			continue
+		}
 
-				curValue[index] = humanDuration
-				if err := unstructured.SetNestedSlice(unstr.Object, curValue, "metadata", "fields"); err != nil {
-					logrus.Errorf("failed to set value back to metadata.fields slice: %s", err.Error())
-					return
-				}
+		dur, ok := isDuration(timeValue)
+		if !ok {
+			millis, err := strconv.ParseInt(timeValue, 10, 64)
+			if err != nil {
+				logrus.Warnf("convert timestamp value: %s failed with error: %s", timeValue, err.Error())
+				continue
 			}
+
+			timestamp := time.Unix(0, millis*int64(time.Millisecond))
+			dur = time.Since(timestamp)
+		}
+
+		humanDuration := duration.HumanDuration(dur)
+		if humanDuration == "<invalid>" {
+			logrus.Warnf("couldn't convert value %d into human duration for column %s", int64(dur), col.Name)
+			continue
+		}
+
+		curValue[index] = humanDuration
+		changedFields = true
+	}
+
+	if changedFields {
+		if err := unstructured.SetNestedSlice(unstr.Object, curValue, "metadata", "fields"); err != nil {
+			logrus.Errorf("failed to set value back to metadata.fields slice: %s", err.Error())
 		}
 	}
 }

pkg/resources/common/formatters/restarts.go

@@ -0,0 +1,43 @@
+package formatters
+
+import (
+	"fmt"
+	"time"
+
+	"k8s.io/apimachinery/pkg/util/duration"
+)
+
+// FormatRestarts formats a restart count array [count, timestamp_ms] as a display string.
+// Examples: "0", "4 (3h38m ago)"
+func FormatRestarts(values []interface{}) string {
+	primary := toInt64(values, 0)
+	secondary := toInt64(values, 1)
+
+	if secondary == 0 {
+		return fmt.Sprintf("%d", primary)
+	}
+
+	// Calculate fresh duration from timestamp
+	timestamp := time.UnixMilli(secondary)
+	dur := time.Since(timestamp)
+	humanDur := duration.HumanDuration(dur)
+
+	return fmt.Sprintf("%d (%s ago)", primary, humanDur)
+}
+
+// toInt64 safely extracts an int64 from a slice at the given index
+func toInt64(arr []interface{}, idx int) int64 {
+	if idx >= len(arr) || arr[idx] == nil {
+		return 0
+	}
+	switch v := arr[idx].(type) {
+	case int64:
+		return v
+	case int:
+		return int64(v)
+	case float64:
+		return int64(v)
+	default:
+		return 0
+	}
+}

pkg/resources/common/formatters/restarts_test.go

@@ -0,0 +1,47 @@
+package formatters
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFormatRestarts(t *testing.T) {
+	// Use current time and calculate expected results
+	now := time.Now()
+
+	tests := []struct {
+		name         string
+		input        []interface{}
+		wantContains string // partial match for dynamic time
+	}{
+		{
+			name:         "count only",
+			input:        []interface{}{0, nil},
+			wantContains: "0",
+		},
+		{
+			name:         "count with recent timestamp (3 hours ago)",
+			input:        []interface{}{4, float64(now.Add(-3 * time.Hour).UnixMilli())},
+			wantContains: "4 (3h",
+		},
+		{
+			name:         "count with old timestamp (48 hours ago)",
+			input:        []interface{}{10, float64(now.Add(-48 * time.Hour).UnixMilli())},
+			wantContains: "10 (2d",
+		},
+		{
+			name:         "count with very recent timestamp (5 minutes ago)",
+			input:        []interface{}{2, float64(now.Add(-5 * time.Minute).UnixMilli())},
+			wantContains: "2 (5m",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := FormatRestarts(tt.input)
+			assert.Contains(t, result, tt.wantContains)
+		})
+	}
+}

pkg/resources/common/util.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/rancher/apiserver/pkg/types"
 	"github.com/rancher/steve/pkg/attributes"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
 // GetIndexValueFromString looks for values between [ ].
@@ -39,3 +40,11 @@ func GetColumnDefinitions(schema *types.APISchema) []ColumnDefinition {
 	}
 	return colDefs
 }
+
+// Common GroupVersionKind definitions used throughout the codebase
+var (
+	PodGVK                 = schema.GroupVersionKind{Group: "", Version: "v1", Kind: "Pod"}
+	EventGVK               = schema.GroupVersionKind{Group: "", Version: "v1", Kind: "Event"}
+	MgmtClusterGVK         = schema.GroupVersionKind{Group: "management.cattle.io", Version: "v3", Kind: "Cluster"}
+	ProvisioningClusterGVK = schema.GroupVersionKind{Group: "provisioning.cattle.io", Version: "v1", Kind: "Cluster"}
+)

pkg/resources/virtual/multivalue/multivalue.go

@@ -0,0 +1,75 @@
+package multivalue
+
+import (
+	rescommon "github.com/rancher/steve/pkg/resources/common"
+	"github.com/sirupsen/logrus"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// ParseFunc transforms a string value into a multi-value array
+type ParseFunc func(string) ([]interface{}, error)
+
+// FieldConfig defines a multi-value field transformation
+type FieldConfig struct {
+	ColumnName string
+	ParseFunc  ParseFunc
+}
+
+// Converter transforms multi-value fields into JSON arrays for storage
+type Converter struct {
+	Columns []rescommon.ColumnDefinition
+	Fields  []FieldConfig
+}
+
+// Transform processes metadata.fields and converts registered multi-value fields
+func (c *Converter) Transform(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	fields, got, err := unstructured.NestedSlice(obj.Object, "metadata", "fields")
+	if err != nil || !got {
+		return obj, err
+	}
+
+	updated := false
+
+	for _, fieldConfig := range c.Fields {
+		index := findColumnIndex(c.Columns, fieldConfig.ColumnName)
+		if index == -1 || index >= len(fields) {
+			continue
+		}
+
+		if fields[index] == nil {
+			continue
+		}
+
+		value, ok := fields[index].(string)
+		if !ok {
+			continue
+		}
+
+		arrayValue, err := fieldConfig.ParseFunc(value)
+		if err != nil {
+			logrus.Debugf("failed to parse %s value %q: %v", fieldConfig.ColumnName, value, err)
+			continue
+		}
+
+		fields[index] = arrayValue
+		updated = true
+	}
+
+	if updated {
+		if err := unstructured.SetNestedSlice(obj.Object, fields, "metadata", "fields"); err != nil {
+			return obj, err
+		}
+	}
+
+	return obj, nil
+}
+
+// findColumnIndex finds the index of a column by name
+func findColumnIndex(columns []rescommon.ColumnDefinition, columnName string) int {
+	for _, col := range columns {
+		if col.Name == columnName {
+			return rescommon.GetIndexValueFromString(col.Field)
+		}
+	}
+	return -1
+}