AlarmInhibitReduce

hertzbeat-alerter/src/main/java/org/apache/hertzbeat/alert/reduce/AlarmInhibitReduce.java

@@ -23,12 +23,14 @@
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
+
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.Collections;
 import java.util.stream.Collectors;
 import java.util.HashMap;
+
 import lombok.Data;
 import lombok.AllArgsConstructor;
 
@@ -46,9 +48,9 @@ public class AlarmInhibitReduce {
     private static final long SOURCE_ALERT_TTL = 4 * 60 * 60 * 1000L;
 
     private final AlarmSilenceReduce alarmSilenceReduce;
-    
+
     private final Map<Long, AlertInhibit> inhibitRules;
-    
+
     /**
      * Cache for source alerts
      * key: ruleId
@@ -63,177 +65,256 @@ public AlarmInhibitReduce(AlarmSilenceReduce alarmSilenceReduce, AlertInhibitDao
         List<AlertInhibit> inhibits = alertInhibitDao.findAlertInhibitsByEnableIsTrue();
         refreshInhibitRules(inhibits);
     }
-    
+
     /**
      * Configure inhibit rules
+     * @param rules Inhibit rule list
      */
     public void refreshInhibitRules(List<AlertInhibit> rules) {
-        this.inhibitRules.clear();
-        rules.forEach(rule -> this.inhibitRules.put(rule.getId(), rule));
+        if (rules == null) {
+            log.warn("Attempted to refresh inhibit rules with null list.");
+            return;
+        }
+        try {
+            this.inhibitRules.clear();
+            rules.forEach(rule -> this.inhibitRules.put(rule.getId(), rule));
+        } catch (Exception e) {
+            log.error("Error refreshing inhibit rules", e);
+        }
     }
 
     /**
      * Process alert with inhibit rules
      * If alert is inhibited, it will not be forwarded
+     * @param groupAlert Grouped and pending alerts to be processed
      */
     public void inhibitAlarm(GroupAlert groupAlert) {
-        if (inhibitRules.isEmpty()) {
-            // No inhibit rules, forward directly
-            alarmSilenceReduce.silenceAlarm(groupAlert);
+        if (groupAlert == null) {
+            log.warn("Received null GroupAlert. Skipping processing.");
             return;
         }
+        try {
+            if (inhibitRules.isEmpty()) {
+                alarmSilenceReduce.silenceAlarm(groupAlert);
+                return;
+            }
 
-        // Check if this alert can be a source alert that inhibits others
-        for (AlertInhibit rule : inhibitRules.values()) {
-            if (isSourceAlert(groupAlert, rule)) {
-                // Cache this alert as active source
-                cacheSourceAlert(groupAlert, rule);
+            for (AlertInhibit rule : inhibitRules.values()) {
+                if (isSourceAlert(groupAlert, rule)) {
+                    cacheSourceAlert(groupAlert, rule);
+                }
             }
-        }
 
-        // Check if this alert should be inhibited
-        if (shouldInhibit(groupAlert)) {
-            log.debug("Alert {} is inhibited", groupAlert);
-            return;
-        }
+            if (shouldInhibit(groupAlert)) {
+                log.debug("Alert {} is inhibited", groupAlert);
+                return;
+            }
 
-        // Forward if not inhibited
-        alarmSilenceReduce.silenceAlarm(groupAlert);
+            alarmSilenceReduce.silenceAlarm(groupAlert);
+        } catch (Exception e) {
+            log.error("Error inhibiting alarm for {}", groupAlert, e);
+        }
     }
 
     /**
      * Check if alert matches inhibit rule source labels
+     * @param alert Grouped and pending alerts to be processed
+     * @param rule The rule of inhibition
      */
     private boolean isSourceAlert(GroupAlert alert, AlertInhibit rule) {
-        // Must be firing status
-        if (!"firing".equals(alert.getStatus())) {
+        if (alert == null || rule == null) {
+            log.warn("Received null alert or rule in isSourceAlert");
+            return false;
+        }
+        try {
+            if (!"firing".equals(alert.getStatus())) {
+                return false;
+            }
+            return matchLabels(alert.getCommonLabels(), rule.getSourceLabels());
+        } catch (Exception e) {
+            log.error("Error checking if alert is source alert", e);
             return false;
         }
-
-        // Check if labels match
-        return matchLabels(alert.getCommonLabels(), rule.getSourceLabels());
     }
 
     /**
      * Check if alert should be inhibited by any active source alerts
+     * @param alert Grouped and pending alerts to be processed
      */
     private boolean shouldInhibit(GroupAlert alert) {
-        // Resolved alerts are never inhibited
-        if ("resolved".equals(alert.getStatus())) {
+        if (alert == null) {
+            log.warn("Received null alert in shouldInhibit");
             return false;
         }
-
-        for (AlertInhibit rule : inhibitRules.values()) {
-            // Check if alert matches target labels
-            if (!matchLabels(alert.getCommonLabels(), rule.getTargetLabels())) {
-                continue;
+        try {
+            if ("resolved".equals(alert.getStatus())) {
+                return false;
             }
 
-            // Check if there are active source alerts for this rule
-            List<GroupAlert> sourceAlerts = getActiveSourceAlerts(rule);
-            if (sourceAlerts.isEmpty()) {
-                continue;
-            }
+            for (AlertInhibit rule : inhibitRules.values()) {
+                if (!matchLabels(alert.getCommonLabels(), rule.getTargetLabels())) {
+                    continue;
+                }
 
-            // Check equal labels
-            for (GroupAlert source : sourceAlerts) {
-                if (matchEqualLabels(source, alert, rule.getEqualLabels())) {
-                    return true;
+                List<GroupAlert> sourceAlerts = getActiveSourceAlerts(rule);
+                if (sourceAlerts.isEmpty()) {
+                    continue;
+                }
+
+                for (GroupAlert source : sourceAlerts) {
+                    if (matchEqualLabels(source, alert, rule.getEqualLabels())) {
+                        return true;
+                    }
                 }
             }
+            return false;
+        } catch (Exception e) {
+            log.error("Error checking if alert should be inhibited", e);
+            return false;
         }
-        return false;
     }
 
     /**
      * Check if all required labels match
+     * @param alertLabels The label of the alarm
+     * @param requiredLabels Labels to be matched
      */
     private boolean matchLabels(Map<String, String> alertLabels, Map<String, String> requiredLabels) {
         if (alertLabels == null || requiredLabels == null) {
+            log.warn("Received null alertLabels or requiredLabels in matchLabels");
+            return false;
+        }
+        try {
+            return requiredLabels.entrySet().stream()
+                    .allMatch(entry -> entry.getValue().equals(alertLabels.get(entry.getKey())));
+        } catch (Exception e) {
+            log.error("Error matching labels", e);
             return false;
         }
-        return requiredLabels.entrySet().stream()
-                .allMatch(entry -> entry.getValue().equals(alertLabels.get(entry.getKey())));
     }
 
     /**
      * Check if equal labels have same values in both alerts
+     * @param source Alarm used to suppress other alarms
+     * @param target Alarm that may be suppressed
+     * @param equalLabels Need to be equal labels
      */
     private boolean matchEqualLabels(GroupAlert source, GroupAlert target, List<String> equalLabels) {
-        if (equalLabels == null || equalLabels.isEmpty()) {
-            return true;
+        if (source == null || target == null) {
+            log.warn("Received null source or target in matchEqualLabels");
+            return false;
+        }
+        try {
+            if (equalLabels == null || equalLabels.isEmpty()) {
+                return true;
+            }
+            Map<String, String> sourceLabels = source.getCommonLabels();
+            Map<String, String> targetLabels = target.getCommonLabels();
+
+            return equalLabels.stream().allMatch(label -> {
+                String sourceValue = sourceLabels.get(label);
+                String targetValue = targetLabels.get(label);
+                return sourceValue != null && sourceValue.equals(targetValue);
+            });
+        } catch (Exception e) {
+            log.error("Error matching equal labels", e);
+            return false;
         }
-        Map<String, String> sourceLabels = source.getCommonLabels();
-        Map<String, String> targetLabels = target.getCommonLabels();
-
-        return equalLabels.stream().allMatch(label -> {
-            String sourceValue = sourceLabels.get(label);
-            String targetValue = targetLabels.get(label);
-            return sourceValue != null && sourceValue.equals(targetValue);
-        });
     }
 
     /**
      * Cache source alert for inhibit rule
+     * @param alert Grouped and pending alerts to be processed
+     * @param rule The rule of inhibition
      */
     private void cacheSourceAlert(GroupAlert alert, AlertInhibit rule) {
-        // Get or create cache for this rule
-        Map<String, SourceAlertEntry> ruleCache = sourceAlertCache.computeIfAbsent(
-            rule.getId(), 
-            k -> new ConcurrentHashMap<>()
-        );
-
-        // Generate fingerprint for deduplication
-        String fingerprint = generateAlertFingerprint(alert);
-
-        // Update or add cache entry
-        SourceAlertEntry entry = new SourceAlertEntry(
-            alert,
-            System.currentTimeMillis(),
-            System.currentTimeMillis() + SOURCE_ALERT_TTL
-        );
-        ruleCache.put(fingerprint, entry);
-
-        // Cleanup expired entries
-        cleanupExpiredEntries(ruleCache);
+        if (alert == null || rule == null) {
+            log.warn("Received null alert or rule in cacheSourceAlert");
+            return;
+        }
+        try {
+            Map<String, SourceAlertEntry> ruleCache = sourceAlertCache.computeIfAbsent(
+                    rule.getId(),
+                    k -> new ConcurrentHashMap<>()
+            );
+
+            String fingerprint = generateAlertFingerprint(alert);
+            SourceAlertEntry entry = new SourceAlertEntry(
+                    alert,
+                    System.currentTimeMillis(),
+                    System.currentTimeMillis() + SOURCE_ALERT_TTL
+            );
+            ruleCache.put(fingerprint, entry);
+            cleanupExpiredEntries(ruleCache);
+        } catch (Exception e) {
+            log.error("Error caching source alert", e);
+        }
     }
 
     /**
      * Get active source alerts for inhibit rule
+     * @param rule The rule of inhibition
      */
     private List<GroupAlert> getActiveSourceAlerts(AlertInhibit rule) {
-        Map<String, SourceAlertEntry> ruleCache = sourceAlertCache.get(rule.getId());
-        if (ruleCache == null || ruleCache.isEmpty()) {
+        if (rule == null) {
+            log.warn("Received null rule in getActiveSourceAlerts");
+            return Collections.emptyList();
+        }
+        try {
+            Map<String, SourceAlertEntry> ruleCache = sourceAlertCache.get(rule.getId());
+            if (ruleCache == null || ruleCache.isEmpty()) {
+                return Collections.emptyList();
+            }
+
+            long now = System.currentTimeMillis();
+            return ruleCache.values().stream()
+                    .filter(entry -> entry.getExpiryTime() > now)
+                    .map(SourceAlertEntry::getAlert)
+                    .collect(Collectors.toList());
+        } catch (Exception e) {
+            log.error("Error getting active source alerts", e);
             return Collections.emptyList();
         }
-
-        long now = System.currentTimeMillis();
-        return ruleCache.values().stream()
-            .filter(entry -> entry.getExpiryTime() > now)
-            .map(SourceAlertEntry::getAlert)
-            .collect(Collectors.toList());
     }
 
     /**
      * Generate fingerprint for alert deduplication
+     * @param alert Grouped and pending alerts to be processed
      */
     private String generateAlertFingerprint(GroupAlert alert) {
-        Map<String, String> labels = new HashMap<>(alert.getCommonLabels());
-        // Remove timestamp related fields
-        labels.remove("timestamp");
-
-        return labels.entrySet().stream()
-            .sorted(Map.Entry.comparingByKey())
-            .map(e -> e.getKey() + ":" + e.getValue())
-            .collect(Collectors.joining(","));
+        if (alert == null) {
+            log.warn("Received null alert in generateAlertFingerprint");
+            return "";
+        }
+        try {
+            Map<String, String> labels = new HashMap<>(alert.getCommonLabels());
+            labels.remove("timestamp");
+
+            return labels.entrySet().stream()
+                    .sorted(Map.Entry.comparingByKey())
+                    .map(e -> e.getKey() + ":" + e.getValue())
+                    .collect(Collectors.joining(","));
+        } catch (Exception e) {
+            log.error("Error generating alert fingerprint", e);
+            return "";
+        }
     }
 
     /**
      * Remove expired entries from cache
+     * @param cache Source alert cache entry map
      */
     private void cleanupExpiredEntries(Map<String, SourceAlertEntry> cache) {
-        long now = System.currentTimeMillis();
-        cache.entrySet().removeIf(entry -> entry.getValue().getExpiryTime() <= now);
+        if (cache == null) {
+            log.warn("Received null cache in cleanupExpiredEntries");
+            return;
+        }
+        try {
+            long now = System.currentTimeMillis();
+            cache.entrySet().removeIf(entry -> entry.getValue().getExpiryTime() <= now);
+        } catch (Exception e) {
+            log.error("Error cleaning up expired entries", e);
+        }
     }
 
     /**