[controller] Preserve original strict failure during migration coercion

When the initial strict parse fails inside normalizeSchemaForMigration,
log strictFailure at INFO before attempting the LOOSE_NUMERICS-based
coercion, and on the post-coercion strict re-check attach strictFailure
as a suppressed exception of whatever the second parse throws.

For non-numeric violations (union default not first branch, bad names,
dangling content) the post-coercion strict parse still fails — and
without chaining, the operator only sees that second exception and has
no idea what was wrong with the source schema. The suppressed entry
puts the original message into the same stack trace.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: xunyin8

services/venice-controller/src/main/java/com/linkedin/venice/controller/VeniceHelixAdmin.java

@@ -2296,10 +2296,21 @@ String normalizeSchemaForMigration(String clusterName, String storeName, String
       AvroSchemaParseUtils.parseSchemaFromJSONStrictValidation(schemaStr);
       return schemaStr;
     } catch (Exception strictFailure) {
+      LOGGER.info(
+          "Strict parse failed for store {} migrating into cluster {}; attempting numeric-default coercion.",
+          storeName,
+          clusterName,
+          strictFailure);
       String coerced = AvroSchemaParseUtils.coerceNumericDefaultsToFieldType(schemaStr);
       // Defensive: anything LOOSE_NUMERICS would have been lenient about (union default not first
-      // branch, bad names, etc.) is outside the coercion scope and must still fail strict.
-      AvroSchemaParseUtils.parseSchemaFromJSONStrictValidation(coerced);
+      // branch, bad names, etc.) is outside the coercion scope and must still fail strict. When it
+      // does, surface the *original* strict failure too — it's the one the operator needs to see.
+      try {
+        AvroSchemaParseUtils.parseSchemaFromJSONStrictValidation(coerced);
+      } catch (Exception coercedFailure) {
+        coercedFailure.addSuppressed(strictFailure);
+        throw coercedFailure;
+      }
       if (!coerced.equals(schemaStr)) {
         LOGGER.info(
             "Coerced numeric default(s) in value schema for store {} migrating into cluster {}.",

services/venice-controller/src/test/java/com/linkedin/venice/controller/TestVeniceHelixAdminWithoutCluster.java

@@ -555,7 +555,7 @@ public void testNormalizeReserializesLegacyNumericDefault() {
     com.linkedin.venice.schema.AvroSchemaParseUtils.parseSchemaFromJSONStrictValidation(normalized);
   }
 
-  @Test(expectedExceptions = Exception.class)
+  @Test
   public void testNormalizeRejectsNonNumericStrictViolation() {
     String cluster = "venice-dest";
     String store = "migrating_store";
@@ -564,6 +564,15 @@ public void testNormalizeRejectsNonNumericStrictViolation() {
 
     VeniceHelixAdmin admin = newNormalizeMock(cluster, store, cfg);
     // Migration context, but the violation is outside the numeric-default tier — must propagate.
-    admin.normalizeSchemaForMigration(cluster, store, NON_NUMERIC_STRICT_VIOLATION_SCHEMA);
+    // The original strict failure must ride along as a suppressed exception so the operator can
+    // see what was actually wrong with the source schema, not just that post-coercion strict tripped.
+    try {
+      admin.normalizeSchemaForMigration(cluster, store, NON_NUMERIC_STRICT_VIOLATION_SCHEMA);
+      Assert.fail("Expected normalize to throw on non-numeric strict violation");
+    } catch (Exception coercedFailure) {
+      Assert.assertTrue(
+          coercedFailure.getSuppressed().length >= 1,
+          "Original strict failure should be attached as a suppressed exception, but none was found");
+    }
   }
 }