Use partial unstructured converter to reduce memory consumption (#155)

Author: jonathan-innis

status/controller.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	opunstructured "github.com/awslabs/operatorpkg/unstructured"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -146,12 +147,12 @@ func (c *Controller[T]) Reconcile(ctx context.Context, req reconcile.Request) (r
 }
 
 type GenericObjectController[T client.Object] struct {
-	*Controller[*unstructuredAdapter[T]]
+	*Controller[*UnstructuredAdapter[T]]
 }
 
 func NewGenericObjectController[T client.Object](client client.Client, eventRecorder record.EventRecorder, opts ...option.Function[Option]) *GenericObjectController[T] {
 	return &GenericObjectController[T]{
-		Controller: NewController[*unstructuredAdapter[T]](client, eventRecorder, opts...),
+		Controller: NewController[*UnstructuredAdapter[T]](client, eventRecorder, opts...),
 	}
 }
 
@@ -168,9 +169,9 @@ func (c *GenericObjectController[T]) Reconcile(ctx context.Context, req reconcil
 }
 
 func (c *Controller[T]) toAdditionalMetricLabels(obj Object) map[string]string {
+	u := opunstructured.ToPartialUnstructured(obj, lo.Values(c.additionalMetricFields)...)
 	return lo.Assign(
 		lo.MapEntries(c.additionalMetricFields, func(k string, v string) (string, string) {
-			u := lo.Must(runtime.DefaultUnstructuredConverter.ToUnstructured(obj))
 			elem, _, _ := unstructured.NestedString(u, lo.Filter(strings.Split(v, "."), func(s string, _ int) bool { return s != "" })...)
 			return toPrometheusLabel(k), elem
 		}),
@@ -179,9 +180,9 @@ func (c *Controller[T]) toAdditionalMetricLabels(obj Object) map[string]string {
 }
 
 func (c *Controller[T]) toAdditionalGaugeMetricLabels(obj Object) map[string]string {
+	u := opunstructured.ToPartialUnstructured(obj, lo.Values(c.additionalGaugeMetricFields)...)
 	return lo.Assign(
 		lo.MapEntries(c.additionalGaugeMetricFields, func(k string, v string) (string, string) {
-			u := lo.Must(runtime.DefaultUnstructuredConverter.ToUnstructured(obj))
 			elem, _, _ := unstructured.NestedString(u, lo.Filter(strings.Split(v, "."), func(s string, _ int) bool { return s != "" })...)
 			return toPrometheusLabel(k), elem
 		}),

status/unstructured_adapter.go

@@ -4,38 +4,38 @@ import (
 	"time"
 
 	"github.com/awslabs/operatorpkg/object"
+	opunstructured "github.com/awslabs/operatorpkg/unstructured"
 	"github.com/samber/lo"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
-// unstructuredAdapter is an adapter for the status.Object interface. unstructuredAdapter
+// UnstructuredAdapter is an adapter for the status.Object interface. unstructuredAdapter
 // makes the assumption that status conditions are found on status.conditions path.
-type unstructuredAdapter[T client.Object] struct {
+type UnstructuredAdapter[T client.Object] struct {
 	unstructured.Unstructured
 }
 
-func NewUnstructuredAdapter[T client.Object](obj client.Object) *unstructuredAdapter[T] {
-	u := unstructured.Unstructured{Object: lo.Must(runtime.DefaultUnstructuredConverter.ToUnstructured(obj))}
-	ua := &unstructuredAdapter[T]{Unstructured: u}
+func NewUnstructuredAdapter[T client.Object](obj client.Object) *UnstructuredAdapter[T] {
+	u := unstructured.Unstructured{Object: opunstructured.ToPartialUnstructured(obj, ".status.conditions")}
+	ua := &UnstructuredAdapter[T]{Unstructured: u}
 	ua.SetGroupVersionKind(object.GVK(obj))
 	return ua
 }
 
-func (u *unstructuredAdapter[T]) GetObjectKind() schema.ObjectKind {
+func (u *UnstructuredAdapter[T]) GetObjectKind() schema.ObjectKind {
 	return u
 }
-func (u *unstructuredAdapter[T]) SetGroupVersionKind(gvk schema.GroupVersionKind) {
+func (u *UnstructuredAdapter[T]) SetGroupVersionKind(gvk schema.GroupVersionKind) {
 	u.Unstructured.SetGroupVersionKind(gvk)
 }
-func (u *unstructuredAdapter[T]) GroupVersionKind() schema.GroupVersionKind {
+func (u *UnstructuredAdapter[T]) GroupVersionKind() schema.GroupVersionKind {
 	return object.GVK(object.New[T]())
 }
 
-func (u *unstructuredAdapter[T]) GetConditions() []Condition {
+func (u *UnstructuredAdapter[T]) GetConditions() []Condition {
 	conditions, _, _ := unstructured.NestedFieldNoCopy(u.Object, "status", "conditions")
 	if conditions == nil {
 		return nil
@@ -58,7 +58,7 @@ func (u *unstructuredAdapter[T]) GetConditions() []Condition {
 		return newCondition
 	})
 }
-func (u *unstructuredAdapter[T]) SetConditions(conditions []Condition) {
+func (u *UnstructuredAdapter[T]) SetConditions(conditions []Condition) {
 	unstructured.SetNestedSlice(u.Object, lo.Map(conditions, func(condition Condition, _ int) interface{} {
 		b := map[string]interface{}{}
 		if condition.Type != "" {
@@ -83,7 +83,7 @@ func (u *unstructuredAdapter[T]) SetConditions(conditions []Condition) {
 	}), "status", "conditions")
 }
 
-func (u *unstructuredAdapter[T]) StatusConditions() ConditionSet {
+func (u *UnstructuredAdapter[T]) StatusConditions() ConditionSet {
 	conditionTypes := lo.Map(u.GetConditions(), func(condition Condition, _ int) string {
 		return condition.Type
 	})

status/unstructured_adapter_test.go

@@ -72,7 +72,7 @@ var _ = Describe("Unstructured Adapter", func() {
 		}
 		conditionObj := status.NewUnstructuredAdapter[*test.CustomObject](testObject)
 		conditionObj.SetConditions(conditions)
-		c, found, err := unstructured.NestedSlice(testObject.Object, "status", "conditions")
+		c, found, err := unstructured.NestedSlice(conditionObj.Object, "status", "conditions")
 		Expect(err).To(BeNil())
 		Expect(found).To(BeTrue())
 		Expect(len(c)).To(BeEquivalentTo(1))

unstructured/unstructured.go

@@ -0,0 +1,95 @@
+package unstructured
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/samber/lo"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// ToPartialUnstructured converts an object to unstructured, but only converts specific field paths
+// This is more memory efficient than using runtime.DefaultUnstructuredConverter since that requires the full
+// object to be converted and stored before extracting specific values from that object
+func ToPartialUnstructured(obj interface{}, fieldPaths ...string) map[string]interface{} {
+	if u, ok := obj.(unstructured.Unstructured); ok {
+		obj = u.UnstructuredContent()
+	}
+	if u, ok := obj.(*unstructured.Unstructured); ok {
+		obj = u.UnstructuredContent()
+	}
+
+	result := make(map[string]interface{})
+	for _, fieldPath := range fieldPaths {
+		_ = extractNestedField(obj, result, lo.Filter(strings.Split(fieldPath, "."), func(s string, _ int) bool { return s != "" })...)
+	}
+	return result
+}
+
+// extractNestedField extracts a field using a path and populates the result map accordingly
+func extractNestedField(obj interface{}, result map[string]interface{}, field ...string) error {
+	v := reflect.ValueOf(obj)
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+	var val reflect.Value
+	switch v.Kind() {
+	case reflect.Struct:
+		for i := range v.Type().NumField() {
+			f := v.Type().Field(i)
+			tag := getJSONKey(f)
+			if f.Name == field[0] || tag == field[0] {
+				val = v.Field(i)
+				break
+			}
+		}
+	case reflect.Map:
+		for _, key := range v.MapKeys() {
+			if key.String() == field[0] {
+				val = v.MapIndex(key)
+				break
+			}
+		}
+	default:
+	}
+	if !val.IsValid() {
+		return fmt.Errorf("field %q not found in %T", field[0], obj)
+	}
+	if len(field) == 1 {
+		// Final field — assign directly
+		result[field[0]] = val.Interface()
+		return nil
+	}
+	// Intermediate map — recurse
+	childMap := map[string]interface{}{}
+	err := extractNestedField(val.Interface(), childMap, field[1:]...)
+	if err != nil {
+		return err
+	}
+	// Merge into parent map
+	if _, ok := result[field[0]]; !ok {
+		result[field[0]] = map[string]interface{}{}
+	}
+	for k, v := range childMap {
+		m, ok := result[field[0]].(map[string]interface{})
+		// In general, this should never happen because we have a check higher up in the function for field existence
+		if !ok {
+			panic(fmt.Sprintf("full field path %q not found in %T", field, obj))
+		}
+		m[k] = v
+	}
+	return nil
+}
+
+// getJSONKey returns the JSON key from a struct tag
+func getJSONKey(field reflect.StructField) string {
+	tag := field.Tag.Get("json")
+	if tag == "" {
+		return field.Name
+	}
+	if commaIdx := strings.Index(tag, ","); commaIdx != -1 {
+		return tag[:commaIdx]
+	}
+	return tag
+}