This is an automated email from the ASF dual-hosted git repository. gongchao pushed a commit to branch alarm-inhibit in repository https://gitbox.apache.org/repos/asf/hertzbeat.git
commit c6ee84262dec5965cfb07e44a4a7882a938c9e66 Author: tomsun28 <[email protected]> AuthorDate: Mon Jan 6 17:29:05 2025 +0800 [improve] update alarm inhibit Signed-off-by: tomsun28 <[email protected]> --- .../alert/reduce/AlarmInhibitReduceTest.java | 209 +++++++++++++++++++-- 1 file changed, 191 insertions(+), 18 deletions(-) diff --git a/hertzbeat-alerter/src/test/java/org/apache/hertzbeat/alert/reduce/AlarmInhibitReduceTest.java b/hertzbeat-alerter/src/test/java/org/apache/hertzbeat/alert/reduce/AlarmInhibitReduceTest.java index a7efb4021..d770ff44c 100644 --- a/hertzbeat-alerter/src/test/java/org/apache/hertzbeat/alert/reduce/AlarmInhibitReduceTest.java +++ b/hertzbeat-alerter/src/test/java/org/apache/hertzbeat/alert/reduce/AlarmInhibitReduceTest.java @@ -38,6 +38,8 @@ package org.apache.hertzbeat.alert.reduce; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -45,11 +47,16 @@ import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.Map; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; import org.apache.hertzbeat.alert.AlerterProperties; import org.apache.hertzbeat.alert.dao.AlertInhibitDao; import org.apache.hertzbeat.common.entity.alerter.AlertInhibit; import org.apache.hertzbeat.common.entity.alerter.GroupAlert; +import org.apache.hertzbeat.common.entity.alerter.SingleAlert; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mock; @@ -76,45 +83,58 @@ class AlarmInhibitReduceTest { MockitoAnnotations.openMocks(this); when(alertInhibitDao.findAlertInhibitsByEnableIsTrue()) .thenReturn(Collections.emptyList()); - when(alerterProperties.getInhibit().getTtl()).thenReturn(60000L); + + // 正确设置 AlerterProperties mock + AlerterProperties.InhibitProperties inhibitProperties = new AlerterProperties.InhibitProperties(); + inhibitProperties.setTtl(60000); + when(alerterProperties.getInhibit()).thenReturn(inhibitProperties); + alarmInhibitReduce = new AlarmInhibitReduce(alarmSilenceReduce, alertInhibitDao, alerterProperties); } @Test void whenNoInhibitRules_shouldForwardAlert() { - GroupAlert alert = createGroupAlert("firing", createLabels("severity", "warning")); + SingleAlert alert = createSingleAlert("firing", "fp1", + createLabels("severity", "warning")); + GroupAlert groupAlert = createGroupAlert("firing", + createLabels("severity", "warning"), + Stream.of(alert).collect(Collectors.toList())); - alarmInhibitReduce.inhibitAlarm(alert); + alarmInhibitReduce.inhibitAlarm(groupAlert); - verify(alarmSilenceReduce).silenceAlarm(alert); + verify(alarmSilenceReduce).silenceAlarm(groupAlert); } @Test void whenSourceAlertMatches_shouldInhibitTargetAlert() { - // Create inhibit rule AlertInhibit rule = AlertInhibit.builder() .id(1L) .enable(true) .sourceLabels(createLabels("severity", "critical")) .targetLabels(createLabels("severity", "warning")) - .equalLabels(Arrays.asList("instance")) + .equalLabels(Collections.singletonList("instance")) .build(); alarmInhibitReduce.refreshInhibitRules(Collections.singletonList(rule)); // Create and process source alert - GroupAlert sourceAlert = createGroupAlert("firing", + SingleAlert sourceAlert = createSingleAlert("firing", "fp1", createLabels("severity", "critical", "instance", "host1")); - alarmInhibitReduce.inhibitAlarm(sourceAlert); + GroupAlert sourceGroupAlert = createGroupAlert("firing", + createLabels("severity", "critical", "instance", "host1"), + Stream.of(sourceAlert).collect(Collectors.toList())); + alarmInhibitReduce.inhibitAlarm(sourceGroupAlert); // Create and process target alert - GroupAlert targetAlert = createGroupAlert("firing", + SingleAlert targetAlert = createSingleAlert("firing", "fp2", createLabels("severity", "warning", "instance", "host1")); - alarmInhibitReduce.inhibitAlarm(targetAlert); + GroupAlert targetGroupAlert = createGroupAlert("firing", + createLabels("severity", "warning", "instance", "host1"), + Stream.of(targetAlert).collect(Collectors.toList())); + alarmInhibitReduce.inhibitAlarm(targetGroupAlert); - // Target alert should be inhibited - verify(alarmSilenceReduce).silenceAlarm(sourceAlert); - verify(alarmSilenceReduce, never()).silenceAlarm(targetAlert); + verify(alarmSilenceReduce).silenceAlarm(sourceGroupAlert); + verify(alarmSilenceReduce, never()).silenceAlarm(targetGroupAlert); } @Test @@ -131,12 +151,14 @@ class AlarmInhibitReduceTest { // Create source alert with different instance GroupAlert sourceAlert = createGroupAlert("firing", - createLabels("severity", "critical", "instance", "host1")); + createLabels("severity", "critical", "instance", "host1"), + Collections.emptyList()); alarmInhibitReduce.inhibitAlarm(sourceAlert); // Create target alert with different instance GroupAlert targetAlert = createGroupAlert("firing", - createLabels("severity", "warning", "instance", "host2")); + createLabels("severity", "warning", "instance", "host2"), + Collections.emptyList()); alarmInhibitReduce.inhibitAlarm(targetAlert); // Both alerts should be forwarded @@ -156,9 +178,11 @@ class AlarmInhibitReduceTest { alarmInhibitReduce.refreshInhibitRules(Collections.singletonList(rule)); GroupAlert sourceAlert = createGroupAlert("firing", - createLabels("severity", "critical")); + createLabels("severity", "critical"), + Collections.emptyList()); GroupAlert resolvedAlert = createGroupAlert("resolved", - createLabels("severity", "warning")); + createLabels("severity", "warning"), + Collections.emptyList()); alarmInhibitReduce.inhibitAlarm(sourceAlert); alarmInhibitReduce.inhibitAlarm(resolvedAlert); @@ -167,10 +191,151 @@ class AlarmInhibitReduceTest { verify(alarmSilenceReduce).silenceAlarm(resolvedAlert); } - private GroupAlert createGroupAlert(String status, Map<String, String> labels) { + @Test + void whenNullGroupAlert_shouldHandleGracefully() { + alarmInhibitReduce.inhibitAlarm(null); + verify(alarmSilenceReduce, never()).silenceAlarm(null); + } + + @Test + void whenEmptyAlertList_shouldPassThrough() { + GroupAlert alert = GroupAlert.builder() + .alerts(new ArrayList<>()) + .build(); + + alarmInhibitReduce.inhibitAlarm(alert); + verify(alarmSilenceReduce).silenceAlarm(alert); + } + + @Test + void whenMultipleSourceAlerts_shouldInhibitAllMatchingTargets() { + AlertInhibit rule = AlertInhibit.builder() + .id(1L) + .enable(true) + .sourceLabels(createLabels("severity", "critical")) + .targetLabels(createLabels("severity", "warning")) + .equalLabels(Collections.singletonList("instance")) + .build(); + + alarmInhibitReduce.refreshInhibitRules(Collections.singletonList(rule)); + + // Create source alerts + SingleAlert sourceAlert1 = createSingleAlert("firing", "fp1", + createLabels("severity", "critical", "instance", "host1")); + SingleAlert sourceAlert2 = createSingleAlert("firing", "fp2", + createLabels("severity", "critical", "instance", "host2")); + GroupAlert sourceGroupAlert = createGroupAlert("firing", null, + new ArrayList<>(Arrays.asList(sourceAlert1, sourceAlert2))); + alarmInhibitReduce.inhibitAlarm(sourceGroupAlert); + + // Create target alerts + SingleAlert targetAlert1 = createSingleAlert("firing", "fp3", + createLabels("severity", "warning", "instance", "host1")); + SingleAlert targetAlert2 = createSingleAlert("firing", "fp4", + createLabels("severity", "warning", "instance", "host2")); + SingleAlert targetAlert3 = createSingleAlert("firing", "fp5", + createLabels("severity", "warning", "instance", "host3")); + GroupAlert targetGroupAlert = createGroupAlert("firing", null, + new ArrayList<>(Arrays.asList(targetAlert1, targetAlert2, targetAlert3))); + + alarmInhibitReduce.inhibitAlarm(targetGroupAlert); + + assertEquals(1, targetGroupAlert.getAlerts().size()); + assertEquals("fp5", targetGroupAlert.getAlerts().get(0).getFingerprint()); + } + + @Test + void whenMultipleInhibitRules_shouldApplyAll() { + AlertInhibit rule1 = AlertInhibit.builder() + .id(1L) + .enable(true) + .sourceLabels(createLabels("severity", "critical")) + .targetLabels(createLabels("severity", "warning")) + .equalLabels(Arrays.asList("instance")) + .build(); + + AlertInhibit rule2 = AlertInhibit.builder() + .id(2L) + .enable(true) + .sourceLabels(createLabels("type", "disk")) + .targetLabels(createLabels("type", "memory")) + .equalLabels(Arrays.asList("host")) + .build(); + + alarmInhibitReduce.refreshInhibitRules(Arrays.asList(rule1, rule2)); + + // Test both rules being applied + SingleAlert sourceAlert = createSingleAlert("firing", "fp1", + createLabels("severity", "critical", "type", "disk", + "instance", "host1", "host", "server1")); + + GroupAlert sourceGroupAlert = GroupAlert.builder() + .alerts(Stream.of(sourceAlert).collect(Collectors.toList())) + .build(); + + alarmInhibitReduce.inhibitAlarm(sourceGroupAlert); + + // Create alerts that match different rules + SingleAlert targetAlert1 = createSingleAlert("firing", "fp2", + createLabels("severity", "warning", "instance", "host1")); + SingleAlert targetAlert2 = createSingleAlert("firing", "fp3", + createLabels("type", "memory", "host", "server1")); + + GroupAlert targetGroupAlert = GroupAlert.builder() + .alerts(Arrays.asList(targetAlert1, targetAlert2)) + .build(); + + alarmInhibitReduce.inhibitAlarm(targetGroupAlert); + + // Both alerts should be inhibited + assertTrue(targetGroupAlert.getAlerts().isEmpty()); + } + + @Test + void whenSourceAlertExpires_shouldNotInhibit() throws InterruptedException { + // Configure short TTL for test + AlerterProperties.InhibitProperties inhibitProperties = new AlerterProperties.InhibitProperties(); + inhibitProperties.setTtl(100); + when(alerterProperties.getInhibit()).thenReturn(inhibitProperties); + alarmInhibitReduce = new AlarmInhibitReduce(alarmSilenceReduce, alertInhibitDao, alerterProperties); + + AlertInhibit rule = AlertInhibit.builder() + .id(1L) + .enable(true) + .sourceLabels(createLabels("severity", "critical")) + .targetLabels(createLabels("severity", "warning")) + .equalLabels(Collections.singletonList("instance")) + .build(); + + alarmInhibitReduce.refreshInhibitRules(Collections.singletonList(rule)); + + // Process source alert + SingleAlert sourceAlert = createSingleAlert("firing", "fp1", + createLabels("severity", "critical", "instance", "host1")); + GroupAlert sourceGroupAlert = createGroupAlert("firing", + createLabels("severity", "critical", "instance", "host1"), + Stream.of(sourceAlert).collect(Collectors.toList())); + alarmInhibitReduce.inhibitAlarm(sourceGroupAlert); + + // Wait for source alert to expire + Thread.sleep(200); + + // Target alert should not be inhibited + SingleAlert targetAlert = createSingleAlert("firing", "fp2", + createLabels("severity", "warning", "instance", "host1")); + GroupAlert targetGroupAlert = createGroupAlert("firing", + createLabels("severity", "warning", "instance", "host1"), + Stream.of(targetAlert).collect(Collectors.toList())); + alarmInhibitReduce.inhibitAlarm(targetGroupAlert); + + verify(alarmSilenceReduce).silenceAlarm(targetGroupAlert); + } + + private GroupAlert createGroupAlert(String status, Map<String, String> labels, List<SingleAlert> alerts) { return GroupAlert.builder() .status(status) .commonLabels(labels) + .alerts(alerts) .build(); } @@ -181,4 +346,12 @@ class AlarmInhibitReduceTest { } return labels; } + + private SingleAlert createSingleAlert(String status, String fingerprint, Map<String, String> labels) { + return SingleAlert.builder() + .status(status) + .fingerprint(fingerprint) + .labels(labels) + .build(); + } } --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
