Merge branch 'fix/ZSTAC-72079@@2' into '5.5.12'

<fix>[ai]: add eval task sort columns for ZQL and SDK fields

See merge request zstackio/zstack!9266

Author: gitlab

conf/db/upgrade/V5.5.12__schema.sql

@@ -1,3 +1,33 @@
 -- ZSTAC-75319: Add normalizedModelName column for GPU spec dedup
 CALL ADD_COLUMN('GpuDeviceSpecVO', 'normalizedModelName', 'VARCHAR(255)', 1, NULL);
 CALL CREATE_INDEX('GpuDeviceSpecVO', 'idx_gpu_spec_normalized_model', 'normalizedModelName');
+
+-- Add totalScore and endTime columns to ModelEvaluationTaskVO for ZQL sorting support
+-- Previously these values were only stored inside the opaque JSON TEXT field,
+-- making them invisible to ZQL ORDER BY queries.
+CALL ADD_COLUMN('ModelEvaluationTaskVO', 'totalScore', 'DOUBLE', 1, NULL);
+CALL ADD_COLUMN('ModelEvaluationTaskVO', 'endTime', 'DATETIME', 1, NULL);
+
+-- Add indexes to support efficient sorting
+CALL CREATE_INDEX('ModelEvaluationTaskVO', 'idx_ModelEvaluationTaskVO_totalScore', 'totalScore');
+CALL CREATE_INDEX('ModelEvaluationTaskVO', 'idx_ModelEvaluationTaskVO_endTime', 'endTime');
+
+-- Backfill totalScore from opaque JSON for existing completed tasks
+-- Uses Json_getKeyValue defined in beforeMigrate.sql for MySQL 5.5+ compatibility
+UPDATE `zstack`.`ModelEvaluationTaskVO`
+SET `totalScore` = CAST(Json_getKeyValue(`opaque`, 'total_score') AS DECIMAL(20,6))
+WHERE `opaque` IS NOT NULL
+  AND `totalScore` IS NULL
+  AND Json_getKeyValue(`opaque`, 'total_score') IS NOT NULL;
+
+-- Backfill endTime from opaque JSON for existing completed/failed tasks
+-- end_time format from Python agent: "MMM dd, yyyy hh:mm:ss a" (e.g. "Jan 01, 2025 10:30:00 AM")
+UPDATE `zstack`.`ModelEvaluationTaskVO`
+SET `endTime` = STR_TO_DATE(
+    Json_getKeyValue(`opaque`, 'end_time'),
+    '%b %d, %Y %h:%i:%s %p'
+)
+WHERE `opaque` IS NOT NULL
+  AND `endTime` IS NULL
+  AND Json_getKeyValue(`opaque`, 'end_time') IS NOT NULL
+  AND Json_getKeyValue(`opaque`, 'end_time') != '';

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;

sdk/src/main/java/org/zstack/sdk/ModelEvaluationTaskInventory.java

@@ -228,4 +228,20 @@ public java.lang.Integer getReadTimeout() {
         return this.readTimeout;
     }
 
+    public java.lang.Double totalScore;
+    public void setTotalScore(java.lang.Double totalScore) {
+        this.totalScore = totalScore;
+    }
+    public java.lang.Double getTotalScore() {
+        return this.totalScore;
+    }
+
+    public java.sql.Timestamp endTime;
+    public void setEndTime(java.sql.Timestamp endTime) {
+        this.endTime = endTime;
+    }
+    public java.sql.Timestamp getEndTime() {
+        return this.endTime;
+    }
+
 }

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;
         }