Fix: Truncate large error messages in status conditions

When upgrading operators, CRD validation errors can be very large (50KB+).
Kubernetes rejects status updates over 32KB with "Too long: may not be more than 32768 bytes".
This causes ClusterExtension upgrades to fail and get stuck.

Added `truncateMessage()` function that cuts messages over 30KB.
Applied to status condition functions that handle large errors:
- `setStatusProgressing()` - handles CRD validation errors
- `ensureAllConditionsWithReason()` - handles resolution errors
- `setInstalledStatusConditionUnknown()` - handles bundle errors

Messages keep important info at the start and add "... [message truncated]" suffix.
Now upgrades complete successfully even with large CRD validation errors.

Added unit tests for truncation logic and CRD error scenarios.

Assisted-by: Cursor

Author: camilamacedo86

internal/operator-controller/controllers/clusterextension_controller.go

@@ -160,7 +160,7 @@ func ensureAllConditionsWithReason(ext *ocv1.ClusterExtension, reason v1alpha1.C
 				Type:               condType,
 				Status:             metav1.ConditionFalse,
 				Reason:             string(reason),
-				Message:            message,
+				Message:            truncateMessage(message),
 				ObservedGeneration: ext.GetGeneration(),
 				LastTransitionTime: metav1.NewTime(time.Now()),
 			}

internal/operator-controller/controllers/common_controller.go

@@ -27,6 +27,23 @@ import (
 	ocv1 "github.com/operator-framework/operator-controller/api/v1"
 )
 
+const (
+	// maxConditionMessageLength is the Kubernetes limit minus some buffer for safety
+	maxConditionMessageLength = 30000
+	// truncationSuffix is added when messages are too long
+	truncationSuffix = "\n\n... [message truncated]"
+)
+
+// truncateMessage cuts long messages to fit Kubernetes condition limits
+func truncateMessage(message string) string {
+	if len(message) <= maxConditionMessageLength {
+		return message
+	}
+
+	maxContent := maxConditionMessageLength - len(truncationSuffix)
+	return message[:maxContent] + truncationSuffix
+}
+
 // setInstalledStatusFromBundle sets the installed status based on the given installedBundle.
 func setInstalledStatusFromBundle(ext *ocv1.ClusterExtension, installedBundle *InstalledBundle) {
 	// Nothing is installed
@@ -71,7 +88,7 @@ func setInstalledStatusConditionUnknown(ext *ocv1.ClusterExtension, message stri
 		Type:               ocv1.TypeInstalled,
 		Status:             metav1.ConditionUnknown,
 		Reason:             ocv1.ReasonFailed,
-		Message:            message,
+		Message:            truncateMessage(message),
 		ObservedGeneration: ext.GetGeneration(),
 	})
 }
@@ -91,7 +108,7 @@ func setStatusProgressing(ext *ocv1.ClusterExtension, err error) {
 
 	if err != nil {
 		progressingCond.Reason = ocv1.ReasonRetrying
-		progressingCond.Message = err.Error()
+		progressingCond.Message = truncateMessage(err.Error())
 	}
 
 	if errors.Is(err, reconcile.TerminalError(nil)) {

internal/operator-controller/controllers/common_controller_test.go

@@ -2,6 +2,8 @@ package controllers
 
 import (
 	"errors"
+	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -64,3 +66,102 @@ func TestSetStatusProgressing(t *testing.T) {
 		})
 	}
 }
+
+func TestTruncateMessage(t *testing.T) {
+	tests := []struct {
+		name     string
+		message  string
+		expected string
+	}{
+		{
+			name:     "short message unchanged",
+			message:  "This is a short message",
+			expected: "This is a short message",
+		},
+		{
+			name:     "empty message unchanged",
+			message:  "",
+			expected: "",
+		},
+		{
+			name:     "exact max length message unchanged",
+			message:  strings.Repeat("a", maxConditionMessageLength),
+			expected: strings.Repeat("a", maxConditionMessageLength),
+		},
+		{
+			name:     "message just over limit gets truncated",
+			message:  strings.Repeat("a", maxConditionMessageLength+1),
+			expected: strings.Repeat("a", maxConditionMessageLength-len(truncationSuffix)) + truncationSuffix,
+		},
+		{
+			name:     "very long message gets truncated",
+			message:  strings.Repeat("word ", 10000) + "finalword",
+			expected: strings.Repeat("word ", 10000)[:maxConditionMessageLength-len(truncationSuffix)] + truncationSuffix,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result := truncateMessage(tc.message)
+			require.Equal(t, tc.expected, result)
+
+			// Verify the result is within the limit
+			require.LessOrEqual(t, len(result), maxConditionMessageLength,
+				"truncated message should not exceed max length")
+
+			// If the original message was over the limit, verify truncation occurred
+			if len(tc.message) > maxConditionMessageLength {
+				require.Contains(t, result, truncationSuffix,
+					"long messages should contain truncation suffix")
+				require.Less(t, len(result), len(tc.message),
+					"truncated message should be shorter than original")
+			}
+		})
+	}
+}
+
+func TestSetStatusProgressingWithLongMessage(t *testing.T) {
+	// Create a very long CRD validation error message
+	longCRDError := fmt.Sprintf("validating upgrade for CRD \"applications.argoproj.io\": %s",
+		strings.Repeat("v1alpha1: ^.spec.generators: unhandled changes found\n", 500))
+
+	ext := &ocv1.ClusterExtension{}
+	err := errors.New(longCRDError)
+	setStatusProgressing(ext, err)
+
+	cond := meta.FindStatusCondition(ext.Status.Conditions, ocv1.TypeProgressing)
+	require.NotNil(t, cond)
+	require.LessOrEqual(t, len(cond.Message), maxConditionMessageLength)
+	require.Contains(t, cond.Message, truncationSuffix)
+	require.Contains(t, cond.Message, "validating upgrade for CRD")
+}
+
+func TestSetInstalledStatusConditionUnknownWithLongMessage(t *testing.T) {
+	longError := strings.Repeat("some long error message ", 2000)
+
+	ext := &ocv1.ClusterExtension{}
+	setInstalledStatusConditionUnknown(ext, longError)
+
+	cond := meta.FindStatusCondition(ext.Status.Conditions, ocv1.TypeInstalled)
+	require.NotNil(t, cond)
+	require.LessOrEqual(t, len(cond.Message), maxConditionMessageLength)
+	require.Contains(t, cond.Message, truncationSuffix)
+}
+
+func TestCRDValidationErrorScenario(t *testing.T) {
+	// Simulate a large CRD validation error like the one in the user's issue
+	crdError := "validating upgrade for CRD \"applications.argoproj.io\": " +
+		strings.Repeat("v1alpha1: ^.spec.generators: unhandled changes found in JSONSchemaProps\n", 1000)
+
+	ext := &ocv1.ClusterExtension{ObjectMeta: metav1.ObjectMeta{Name: "test-extension"}}
+	err := errors.New(crdError)
+	setStatusProgressing(ext, err)
+
+	cond := meta.FindStatusCondition(ext.Status.Conditions, ocv1.TypeProgressing)
+	require.NotNil(t, cond)
+	require.LessOrEqual(t, len(cond.Message), maxConditionMessageLength)
+	require.Contains(t, cond.Message, truncationSuffix)
+	require.Contains(t, cond.Message, "validating upgrade for CRD")
+	require.Equal(t, metav1.ConditionTrue, cond.Status)
+	require.Equal(t, ocv1.ReasonRetrying, cond.Reason)
+}