fix: resolve incorrect alert rule group matching (#1274)

Author: VikaCep

src/data/useGMAlerts.test.ts

@@ -20,6 +20,21 @@ describe('findRelevantAlertGroups', () => {
     name: ALERT_NAME,
   };
 
+  const RULE_5M: PrometheusAlertingRule = {
+    ...MATCHING_RULE,
+    name: `${ALERT_NAME} [5m]`,
+  };
+
+  const RULE_10M: PrometheusAlertingRule = {
+    ...MATCHING_RULE,
+    name: `${ALERT_NAME} [10m]`,
+  };
+
+  const RULE_30M: PrometheusAlertingRule = {
+    ...MATCHING_RULE,
+    name: `${ALERT_NAME} [30m]`,
+  };
+
   const NON_MATCHING_RULE: PrometheusAlertingRule = {
     ...MATCHING_RULE,
     name: 'OtherAlert',
@@ -82,4 +97,101 @@ describe('findRelevantAlertGroups', () => {
       }),
     ]);
   });
+
+  describe('period-based alert matching', () => {
+    const GROUP_5M: PrometheusAlertsGroup = {
+      evaulationTime: 1,
+      file: 'Grafana Synthetic Monitoring',
+      folderUid: 'grafana-synthetic-monitoring-app',
+      interval: 300,
+      lastEvaluation: 'now',
+      name: 'Failed Checks [5m]',
+      rules: [RULE_5M],
+      totals: null,
+    };
+
+    const GROUP_10M: PrometheusAlertsGroup = {
+      ...GROUP_5M,
+      name: 'Failed Checks [10m]',
+      rules: [RULE_10M],
+    };
+
+    const GROUP_30M: PrometheusAlertsGroup = {
+      ...GROUP_5M,
+      name: 'Failed Checks [30m]',
+      rules: [RULE_30M],
+    };
+
+    test('matches exact period when period is specified', () => {
+      const alerts: CheckAlertPublished[] = [{ 
+        name: ALERT_NAME, 
+        period: '5m',
+        ...baseAlert 
+      }];
+      
+      // Test the scenario from the escalation: 10m group comes first in array
+      const groups = [GROUP_10M, GROUP_30M, GROUP_5M];
+      const result = findRelevantAlertGroups(groups, alerts);
+      
+      expect(result).toStrictEqual([
+        {
+          ...GROUP_5M,
+          rules: [RULE_5M],
+        },
+      ]);
+    });
+
+    test('matches 10m period correctly even when 5m exists', () => {
+      const alerts: CheckAlertPublished[] = [{ 
+        name: ALERT_NAME, 
+        period: '10m',
+        ...baseAlert 
+      }];
+      
+      const groups = [GROUP_5M, GROUP_10M, GROUP_30M];
+      const result = findRelevantAlertGroups(groups, alerts);
+      
+      expect(result).toStrictEqual([
+        {
+          ...GROUP_10M,
+          rules: [RULE_10M],
+        },
+      ]);
+    });
+
+    test('handles alert without period (backward compatibility)', () => {
+      const alerts: CheckAlertPublished[] = [{ 
+        name: ALERT_NAME,
+        ...baseAlert 
+      }];
+      
+      const groups = [GROUP];
+      const result = findRelevantAlertGroups(groups, alerts);
+      
+      expect(result).toStrictEqual([
+        {
+          ...GROUP,
+          rules: [MATCHING_RULE],
+        },
+      ]);
+    });
+
+    test('creates dummy group when no matching period rule exists', () => {
+      const alerts: CheckAlertPublished[] = [{ 
+        name: ALERT_NAME, 
+        period: '15m', // This period doesn't exist in any group
+        ...baseAlert 
+      }];
+      
+      const groups = [GROUP_5M, GROUP_10M, GROUP_30M];
+      const result = findRelevantAlertGroups(groups, alerts);
+      
+      expect(result).toStrictEqual([
+        expect.objectContaining({
+          name: CATEGORY,
+          rules: [expect.objectContaining({ name: ALERT_NAME })],
+        }),
+      ]);
+    });
+  });
 }); 

src/data/useGMAlerts.ts

@@ -43,13 +43,15 @@ function queryAlertApi() {
 
 function findGroupWithMatchingRule(
   groups: PrometheusAlertsGroup[],
-  alertName: string
+  alert: { name: string; period?: string }
 ): PrometheusAlertsGroup | undefined {
-  return groups.find((group) => group.rules.some((rule) => rule.name.includes(alertName)));
+  const fullAlertName = alert.period ? `${alert.name} [${alert.period}]` : alert.name;
+  return groups.find((group) => group.rules.some((rule) => rule.name === fullAlertName));
 }
 
-function extractMatchingRules(group: PrometheusAlertsGroup, alertName: string) {
-  return group.rules.filter((rule) => rule.name.includes(alertName));
+function extractMatchingRules(group: PrometheusAlertsGroup, alert: { name: string; period?: string }) {
+  const fullAlertName = alert.period ? `${alert.name} [${alert.period}]` : alert.name;
+  return group.rules.filter((rule) => rule.name === fullAlertName);
 }
 
 function constructDummyGroup(alertName: string): PrometheusAlertsGroup {
@@ -92,11 +94,11 @@ export function findRelevantAlertGroups(
   const grafanaGroups = groups.filter((group) => group.folderUid === GRAFANA_SM_FOLDER_UID);
 
   return alerts.map((alert) => {
-    const groupWithRule = findGroupWithMatchingRule(grafanaGroups, alert.name);
+    const groupWithRule = findGroupWithMatchingRule(grafanaGroups, alert);
     if (groupWithRule) {
       return {
         ...groupWithRule,
-        rules: extractMatchingRules(groupWithRule, alert.name),
+        rules: extractMatchingRules(groupWithRule, alert),
       };
     }
     return constructDummyGroup(alert.name);