<fix>[core]: redesign StringSimilarity to match fmt template first

Redesign findSimilar() with a three-phase strategy to prevent
performance degradation when operr() format args contain very
long strings (e.g., serialized ErrorCodeList or HTML bodies):

Phase 1: regex match against raw fmt template (always short).
Phase 2: fallback to formatted string only if Phase 1 misses
         and length <= maxElaborationRegex (8192).
Phase 3: distance match always uses raw fmt template.

Also add length guard in findMostSimilarRegex() and remove
redundant String.format length check in Platform.elaborate().

Root cause: StringSimilarity.findSimilar() was running 199
regex patterns via ReTree against multi-KB formatted strings,
causing 7+ second latency in error code creation hot paths.

Resolves: ZSTAC-72079

Change-Id: I38b98a762deb436da31e4884da05d12b38b98a76

Author: Shangmin Dou

core/src/main/java/org/zstack/core/Platform.java

@@ -938,10 +938,6 @@ public static boolean killProcess(int pid, Integer timeout) {
 
     private static ErrorCodeElaboration elaborate(String fmt, Object...args) {
         try {
-            if (String.format(fmt, args).length() > StringSimilarity.maxElaborationRegex) {
-                return null;
-            }
-
             ErrorCodeElaboration elaboration = StringSimilarity.findSimilar(fmt, args);
             if (elaboration == null) {
                 return null;

utils/src/main/java/org/zstack/utils/string/StringSimilarity.java

@@ -287,6 +287,15 @@ private static void logSearchSpend(String sub, long start, boolean found) {
     /**
      * find the most similar error code elaboration for the given error message.
      *
+     * The method uses a two-phase strategy to avoid performance degradation
+     * when format args produce very long strings (e.g., serialized error chains
+     * or HTML response bodies):
+     *
+     * Phase 1: Try regex matching with the formatted string (length-guarded).
+     * Phase 2: If Phase 1 misses (or formatted string too long), fallback
+     *          to the raw fmt template for regex matching.
+     * Phase 3: Distance matching always uses the raw fmt template.
+     *
      * @param sub error message or error message fmt
      * @param args arguments
      * @return the most similar error code elaboration
@@ -311,23 +320,41 @@ public static ErrorCodeElaboration findSimilar(String sub, Object...args) {
             errors.remove(sub);
         }
 
-        if (args != null && missed.get(String.format(sub, args)) != null) {
-            logSearchSpend(sub, start, false);
-            return null;
-        } else if (missed.get(sub) != null) {
+        // check missed cache for both fmt template and formatted string
+        if (missed.get(sub) != null) {
             logSearchSpend(sub, start, false);
             return null;
         }
+        if (args != null) {
+            try {
+                String formatted = String.format(sub, args);
+                if (missed.get(formatted) != null) {
+                    logSearchSpend(sub, start, false);
+                    return null;
+                }
+            } catch (Exception e) {
+                logger.trace(String.format("failed to format elaboration key: %s", e.getMessage()));
+            }
+        }
 
-        try {
-            logger.trace(String.format("start to search elaboration for: %s", String.format(sub, args)));
-            err = findMostSimilarRegex(String.format(sub, args));
-        } catch (Exception e) {
-            logger.trace(String.format("start search elaboration for: %s", sub));
+        // Phase 1: try regex matching with formatted string (guarded by length limit)
+        if (args != null && args.length > 0) {
+            try {
+                String formatted = String.format(sub, args);
+                if (formatted.length() <= maxElaborationRegex) {
+                    err = findMostSimilarRegex(formatted);
+                }
+            } catch (Exception e) {
+                logger.trace(String.format("failed to format for regex matching: %s", e.getMessage()));
+            }
+        }
+
+        // Phase 2: if formatted string missed or was too long, fallback to raw fmt template
+        if (err == null) {
             err = findMostSimilarRegex(sub);
         }
 
-        // find by distance is not reliable disable it for now
+        // Phase 3: distance matching uses the raw fmt template (always short)
         if (err == null) {
             err = findSimilarDistance(sub);
         }
@@ -355,6 +382,10 @@ private static boolean verifyElaboration(ErrorCodeElaboration elaboration, Strin
 
     // better precision, worse performance
     private static ErrorCodeElaboration findMostSimilarRegex(String sub) {
+        if (sub.length() > maxElaborationRegex) {
+            return null;
+        }
+
         if (!isRegexMatchedByRetrees(sub)) {
             return null;
         }